Initiation

Cours dInformatique S1
Initiation ` lalgorithmique
a
Jacques TISSEAU
LISYC EA 3883 UBO-ENIB-ENSIETA
Centre Europeen de Realite Virtuelle

tisseau@enib.fr
Ces notes de cours accompagnent les enseignements dinformatique du 1er semestre (S1) de
lEcole Nationale dIngnieurs de Brest (ENIB : www.enib.fr). Leur lecture ne dispense en
e
aucun cas dune prsence attentive aux cours ni dune participation active aux travaux dirigs.
e
e
version du 01 septembre 2009
Avec la participation de Romain Benard, Stephane
Bonneaud, Cedric Buche, Gireg Desmeulles, Eric
Maisel, Alexis Nedelec, Marc Parenthoen et Cyril Septseault.
Sommaire
1 Introduction gnrale
e e
1.1 Contexte scientique . . .
1.2 Objectifs du cours . . . .
1.3 Organisation du cours . .
1.4 Mthodes de travail . . .
e
1.5 Exercices complmentaires
e
1.6 Annexes . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
4
11
13
16
20
31
2 Instructions de base
2.1 Introduction . . . . . . . .
2.2 Aectation . . . . . . . .
2.3 Tests . . . . . . . . . . . .
2.4 Boucles . . . . . . . . . .
e
2.6 Annexes . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
39
40
42
46
51
63
91
3 Procdures et fonctions
e
3.1 Introduction . . . . . . . .
3.2 Dnition dune fonction .
e
3.3 Appel dune fonction . . .
e
3.5 Annexes . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
99
100
104
115
128
152
4 Structures linaires
e
4.1 Introduction . . . . . . . . . .
4.2 Squences . . . . . . . . . . .
e
4.3 Recherche dans une squence
e
4.4 Tri dune squence . . . . . .
e
4.5 Exercices complmentaires . .
e
4.6 Annexes . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
157
158
162
170
173
180
193
A Grands classiques
207
B Travaux dirigs
e
223
C Contrles types
o
231
Index
252
Liste des gures
257
Liste des exemples
261
Liste des exercices
263
Rfrences
ee
271
Chaque programme dordinateur est un mod`le, forg par lesprit, dun

e
e
processus rel ou imaginaire. Ces processus, qui naissent de lexprience
e
e
et de la pense de lhomme, sont innombrables et complexes dans leurs
e
dtails. A tout moment, ils ne peuvent tre compris que partiellement. Ils
e
e
ne sont que rarement modliss dune faon satisfaisante dans nos proe e
c
grammes informatiques. Bien que nos programmes soient des ensembles
de symboles cisels avec soin, des mosa
e
ques de fonctions entrecroises,
e
ils ne cessent dvoluer. Nous les modions au fur et ` mesure que notre
e
a
perception du mod`le sapprofondit, stend et se gnralise, jusqu` ate
e
e e
a
teindre un quilibre mtastable aux fronti`res dune autre modlisation
e
e
e
e
possible du probl`me. Livresse joyeuse qui accompagne la programmae
tion des ordinateurs provient des allers-retours continuels, entre lesprit
humain et lordinateur, des mcanismes exprims par des programmes
e
e
et de lexplosion de visions nouvelles quils apportent. Si lart traduit
nos rves, lordinateur les ralise sous la forme de programmes !
e
e
Abelson H., Sussman G.J. et Sussman J., [1]
Chapitre 1
Introduction gnrale
e e
Sommaire
1.1
Informatique
S1
1.2
1.3
a
introduction gnrale
e e
1.4
Jacques TISSEAU
1.5
Ecole Nationale dIngenieurs de Brest

Technople Brest-Iroise
o
CS 73862 - 29238 Brest cedex 3 - France
enib c 2009
1.6
tisseau@enib.fr
enib c 2009
Algorithmique
1/18
Contexte scientique . . . . . . . . . . . . . .
1.1.1 Informatique . . . . . . . . . . . . . . .
1.1.2 Algorithmique . . . . . . . . . . . . . .
1.1.3 Programmation . . . . . . . . . . . . .
Objectifs du cours . . . . . . . . . . . . . . . .
1.2.1 Objectifs thmatiques . . . . . . . . .
e
1.2.2 Objectifs pdagogiques . . . . . . . . .
e
1.2.3 Objectifs comportementaux . . . . . .
Organisation du cours . . . . . . . . . . . . . .
1.3.1 Prsentiel . . . . . . . . . . . . . . . . .
e
1.3.2 Documents . . . . . . . . . . . . . . . .
1.3.3 Evaluations des apprentissages . . . .
1.3.4 Evaluation des enseignements . . . .
Mthodes de travail . . . . . . . . . . . . . . .
e
1.4.1 Avant, pendant et apr`s le cours . . .
e
1.4.2 Avant, pendant et apr`s le laboratoire
e
1.4.3 Apprendre en faisant . . . . . . . . . .
Exercices complmentaires . . . . . . . . . . .
e
1.5.1 Conna
tre . . . . . . . . . . . . . . . . .
1.5.2 Comprendre . . . . . . . . . . . . . . .
1.5.3 Appliquer . . . . . . . . . . . . . . . . .
1.5.4 Analyser . . . . . . . . . . . . . . . . .
1.5.5 Solutions des exercices . . . . . . . . .
Annexes . . . . . . . . . . . . . . . . . . . . . .
1.6.1 Lettre de Jacques Perret . . . . . . .
1.6.2 Exemple de questionnaire dvaluation
e
1.6.3 Exemple de planning . . . . . . . . . .
1.6.4 Informatique ` lENIB . . . . . . . . .
a
4
4
5
8
11
11
11
12
13
13
13
14
16
16
16
18
19
20
20
22
22
23
26
31
31
33
34
35

CHAPITRE 1. INTRODUCTION GENERALE
1.1
Fig. 1.1 : Definitions de lAcademie (1)

INFORMATIQUE n. f. et adj. XXe si`cle. Driv
e
e e
dinformation sur le mod`le de mathmatique,
e
e
lectronique. 1. N. f. Science du traitement rationnel
e
et automatique de linformation ; lensemble des applications de cette science. 2. Adj. Qui se rapporte `
a
linformatique. Syst`me informatique, ensemble des
e
moyens qui permettent de conserver, de traiter et de
transmettre linformation.
INSTRUCTION n. f. XIVe si`cle. Emprunt du
e
e
latin instructio, action dadapter, de ranger , puis
instruction . Ordre, indication quon donne `
a
quelquun pour la conduite dune aaire ; directive,
consigne. Le plus souvent au pluriel. Des instructions verbales, crites. Donner des instructions ` ses
e
a
collaborateurs. Instructions pour la mise en marche
dun appareil. Par anal. INFORM. Consigne formule dans un langage de programmation, selon un
e
code.
LOGICIEL n. m. XXe si`cle. Driv de logique.
e
e e
INFORM. Ensemble structur de programmes reme
plissant une fonction dtermine, permettant lace
e
complissement dune tche donne.
a
e
MATERIEL adj. et n. XIIIe si`cle. Emprunt du

e
e
latin materialis, de mme sens. INFORM. Ensemble
e
des lments physiques employs pour le traitement
ee
e
des donnes, par opposition aux logiciels.
e
ORDINATEUR n. m. XVe si`cle, au sens de cee
lui qui institue quelque chose ; XXe si`cle, au
e
sens actuel. Emprunt du latin ordinator, celui qui
e
r`gle, met en ordre ; ordonnateur . Equipement ine

formatique comprenant les organes ncessaires ` son
e
a
fonctionnement autonome, qui assure, en excutant
e
les instructions dun ensemble structur de proe
grammes, le traitement rapide de donnes codes
e
e
sous forme numrique qui peuvent tre conserves
e
e
e
et transmises.
1.1.1
Contexte scientique
Informatique
Le terme informatique est un nologisme propos en 1962 par Philippe Dreyfus pour
e
e
caractriser le traitement automatique de linformation : il est construit sur la contraction de
e
lexpression information automatique . Ce terme a t accept par lAcadmie franaise en
ee
e
e
c
avril 1966, et linformatique devint alors ociellement la science du traitement automatique
de linformation, o` linformation est considre comme le support des connaissances humaines
u
ee
et des communications dans les domaines techniques, conomiques et sociaux (gure 1.1). Le
e
mot informatique na pas vraiment dquivalent aux Etats-Unis o` lon parle de Computing
e
u
Science (science du calcul) alors que Informatics est admis par les Britanniques.
Dnition 1.1 : informatique
e
Linformatique est la science du traitement automatique de linformation.
Linformatique traite de deux aspects complmentaires : les programmes immatriels (logie
e
ciel, software) qui dcrivent un traitement ` raliser et les machines (matriel, hardware) qui
e
a e
e
excutent ce traitement. Le matriel est donc lensemble des lments physiques (microprocese
e
ee
seur, mmoire, cran, clavier, disques durs. . .) utiliss pour traiter les donnes. Dans ce contexte,
e
e
e
e
lordinateur est un terme gnrique qui dsigne un quipement informatique permettant de traie e
e
e
ter des informations selon des squences dinstructions (les programmes) qui constituent le loe
giciel. Le terme ordinateur a t propos par le philologue Jacques Perret en avril 1955 en
ee
e
rponse ` une demande dIBM France qui estimait le mot calculateur (computer) bien trop
e
a
restrictif en regard des possibilits de ces machines (voir la proposition de Jacques Perret en
e
annexe 1.6.1 page 31).
Dnition 1.2 : materiel

e
Le matriel informatique est un ensemble de dispositifs physiques utiliss pour traiter automatie
e
quement des informations.
Dnition 1.3 : logiciel
e
Le logiciel est un ensemble structur dinstructions dcrivant un traitement dinformations `
e
e
a
faire raliser par un matriel informatique.
e
e
Un ordinateur nest rien dautre quune machine eectuant des oprations simples sur des
e
squences de signaux lectriques, lesquels sont conditionns de mani`re ` ne pouvoir prendre
e
e
e
e a
1.1. CONTEXTE SCIENTIFIQUE
que deux tats seulement (par exemple un potentiel lectrique maximum ou minimum). Ces
e
e
squences de signaux obissent ` une logique binaire du type tout ou rien et peuvent donc
e
e
a
tre considrs conventionnellement comme des suites de nombres ne prenant jamais que les
e
ee
deux valeurs 0 et 1 : un ordinateur est donc incapable de traiter autre chose que des nombres
binaires. Toute information dun autre type doit tre convertie, ou code, en format binaire.
e
e
Cest vrai non seulement pour les donnes que lon souhaite traiter (les nombres, les textes,
e
les images, les sons, les vidos, etc.), mais aussi pour les programmes, cest-`-dire les squences
e
a
e
dinstructions que lon va fournir ` la machine pour lui dire ce quelle doit faire avec ces donnes.
a
e
Larchitecture matrielle dun ordinateur repose sur le mod`le de Von Neumann (gure 1.2)
e
e
qui distingue classiquement 4 parties (gure 1.3) :
Fig. 1.2 : John Von Neumann (1903-1957)

Mathmaticien
e
amricain
e
dorigine hongroise : il a
donn son nom ` larchie
a
tecture de von Neumann
utilise dans la quasi totalit
e
e
des ordinateurs modernes
(voir gure 1.3 ci-dessous).
1. Lunit arithmtique et logique, ou unit de traitement, eectue les oprations de base.

e
e
e
e
2. Lunit de contrle squence les oprations.
e
o e
e
3. La mmoire contient ` la fois les donnes et le programme qui dira ` lunit de contrle quels
e
a
e
a
e
o
calculs faire sur ces donnes. La mmoire se divise entre mmoire vive volatile (programmes
e
e
e
et donnes en cours de fonctionnement) et mmoire de masse permanente (programmes et
e
e
donnes de base de la machine).
e
4. Les entres-sorties sont des dispositifs permettant de communiquer avec le monde extrieur
e
e
(cran, clavier, souris. . .).
e
Fig. 1.3 : Architecture de Von Neumann

mmoire
Les 2 premi`res parties sont souvent rassembles au sein dune mme structure : le microe
e
e
processeur (la puce ), unit centrale de lordinateur.
e
Dans ce cours, nous ne nous intresserons quaux aspects logiciels de linformatique.
e
1.1.2
Algorithmique

Exemple 1.1 : Mode demploi dun telecopieur
Extrait du mode demploi dun tlcopieur concernant lenvoi dun document.
ee
unit de
contrle
unit
arithmtique
et logique
1. Insrez le document dans le chargeur automatique.

e
2. Composez le numro de fax du destinataire ` laide du pav numrique.
e
a
e
e
3. Enfoncez la touche envoi pour lancer lmission.
e
Ce mode demploi prcise comment envoyer un fax. Il est compos dune suite ordonne dinse
e
e
tructions (insrez. . ., composez. . ., enfoncez. . .) qui manipulent des donnes (document, chargeur
e
e
entre
sortie
TD 1.1 : Dessins sur la plage : execution (1)

On cherche ` faire dessiner une gure gomtrique sur la
a
e e
plage ` quelquun qui a les yeux bands.
a
e
Quelle gure gomtrique dessine-t-on en excutant la
e e
e
suite dinstructions ci-dessous ?
1. avance de 10 pas,
2. tourne ` gauche dun angle de 120 ,
a
a
5. avance de 10 pas.
TD 1.2 : Dessins sur la plage : conception (1)
Faire dessiner une spirale rectangulaire de 5 cts, le plus
oe
petit ct faisant 2 pas de long et chaque ct fait un pas
oe
oe
de plus que le prcdent.
e e

ALGORITHME n. m. XIIIe si`cle, augorisme.
e
Altration, sous linuence du grec arithmos,
e
nombre , dalgorisme, qui, par lespagnol,
remonte ` larabe Al-Khuwarizmi, surnom dun
a
mathmaticien. Mthode de calcul qui indique la
e
e
dmarche ` suivre pour rsoudre une srie de
e
a
e
e
probl`mes quivalents en appliquant dans un ordre
e
e
prcis une suite nie de r`gles.
e
e
DONNEE n. f. XIIIe si`cle, au sens de distrie

bution, aumne ; XVIIIe si`cle, comme terme de
o
e
mathmatiques. Participe pass fminin substantiv
e
e e
e
de donner au sens de indiquer, dire . 1. Fait ou
principe indiscut, ou considr comme tel, sur lee
e e
quel se fonde un raisonnement ; constatation servant
de base ` un examen, une recherche, une dcouverte.
a
e
INFORM. Reprsentation dune information sous
e
une forme conventionnelle adapte ` son exploitae a
tion.

automatique, numro de fax, pav numrique, touche envoi) pour raliser la tche dsire (envoi
e
e
e
e
a
e e
dun document).
Chacun a dj` t confront ` de tels documents pour faire fonctionner un appareil plus ou
eaee
ea
moins rticent et donc, consciemment ou non, a dj` excut un algorithme (ie. excuter la suite
e
ea e e
e
dinstructions dans lordre annonc, gure 1.4).
e
TD1.1
Dnition 1.4 : algorithme
e
Un algorithme est une suite ordonne dinstructions qui indique la dmarche ` suivre pour
e
e
a
rsoudre une srie de probl`mes quivalents.
e
e
e
e
Exemple 1.2 : Trouver son chemin
Extrait dun dialogue entre un touriste gar et un autochtone.
e e
Pourriez-vous mindiquer le chemin de la gare, sil vous plait ?
Oui bien sr : vous allez tout droit jusquau prochain carrefour, vous prenez ` gauche au
u
a
carrefour et ensuite la troisi`me ` droite, et vous verrez la gare juste en face de vous.
e
a
Merci.
Dans ce dialogue, la rponse de lautochtone est la description dune suite ordonne dinse
e
tructions (allez tout droit, prenez ` gauche, prenez la troisi`me ` droite) qui manipulent des
a
e
a
donnes (carrefour, rues) pour raliser la tche dsire (aller ` la gare). Ici encore, chacun a
e
e
a
e e
a
dj` t confront ` ce genre de situation et donc, consciemment ou non, a dj` construit un
eaee
ea
ea
algorithme dans sa tte (ie. dnir la suite dinstructions pour raliser une tche). Mais quand
e
e
e
a
on dnit un algorithme, celui-ci ne doit contenir que des instructions comprhensibles par celui
e
e
qui devra lexcuter (des humains dans les 2 exemples prcdents).
e
e e
TD1.2
Dans ce cours, nous devrons apprendre ` dnir des algorithmes pour quils soient compra e
e
hensibles et donc excutables par un ordinateur.
e
Dnition 1.5 : algorithmique
e
Lalgorithmique est la science des algorithmes.
Lalgorithmique sintresse ` lart de construire des algorithmes ainsi qu` caractriser leur
e
a
a
e
validit, leur robustesse, leur rutilisabilit, leur complexit ou leur ecacit.
e
e
e
e
e
Dnition 1.6 : validite dun algorithme

e
La validit dun algorithme est son aptitude a raliser exactement la tche pour laquelle il a t
e
` e
a
ee
conu.
c
Si lon reprend lexemple 1.2 de lalgorithme de recherche du chemin de la gare, ltude de sa

e
validit consiste ` sassurer quon arrive eectivement ` la gare en excutant scrupuleusement
e
a
a
e
les instructions dans lordre annonc.
e
Dnition 1.7 : robustesse dun algorithme
e
La robustesse dun algorithme est son aptitude ` se protger de conditions anormales dutilisaa
e
tion.
Dans lexemple 1.2, la question de la robustesse de lalgorithme se pose par exemple si le chemin
propos a t pens pour un piton, alors que le touriste gar est en voiture et que la
e ee
e
e
e e
troisi`me ` droite est en sens interdit.
e
a
Dnition 1.8 : reutilisabilite dun algorithme

e
La rutilisabilit dun algorithme est son aptitude ` tre rutilis pour rsoudre des tches
e
e
a e
e
e
e
a
quivalentes ` celle pour laquelle il a t conu.
e
a
ee
c
Lalgorithme de recherche du chemin de la gare est-il rutilisable tel quel pour se rendre ` la
e
a
mairie ? A priori non, sauf si la mairie est juste ` ct de la gare.
a oe
Dnition 1.9 : complexite dun algorithme

e
La complexit dun algorithme est le nombre dinstructions lmentaires ` excuter pour raliser
e
ee
a e
e
la tche pour laquelle il a t conu.
a
ee
c

TD 1.3 : Proprietes dun algorithme
Reprendre le TD 1.1 et illustrer la validit, la robustesse,
e
la rutilisabilit, la complexit et lecacit de lalgoe
e
e
e
rithme propos pour dessiner sur la plage.
e
`
Fig. 1.5 : Du probleme au code source
problme
algorithmique
Si le touriste gar est un piton, la complexit de lalgorithme de recherche de chemin peut

e e
e
e
se compter en nombre de pas pour arriver ` la gare.
a
Dnition 1.10 : efficacite dun algorithme

e
Lecacit dun algorithme est son aptitude ` utiliser de mani`re optimale les ressources du
e
a
e
matriel qui lexcute.
e
e
Nexisterait-il pas un raccourci pitonnier pour arriver plus vite ` la gare ?
e
a
TD1.3
Lalgorithmique permet ainsi de passer dun probl`me ` rsoudre ` un algorithme qui dcrit
e
a e
a
e
la dmarche de rsolution du probl`me. La programmation a alors pour rle de traduire cet
e
e
e
o
algorithme dans un langage comprhensible par lordinateur an quil puisse excuter lale
e
gorithme automatiquement (gure 1.5).
algorithme
programmation
code source

1.1.3

LANGAGE. n. m. XIIe si`cle. Driv de langue.
e
e e
Syst`me de signes, de symboles, labor ` partir des
e
e
ea
langues naturelles et constituant un code qui les remplace dans certains cas dtermins (on parle aussi de
e
e
langage symbolique). Le langage mathmatique. Lane
gage logique, fond sur la logique formelle. Langage
e
informatique. Langage de programmation.
BIT n. m. XXe si`cle. Mot anglo-amricain,
e
e
contraction de binary digit, chire binaire . Chacun des deux chires, 0 et 1, de la numration bie
naire. En informatique, le bit est lunit lmentaire
eee
dinformation appele aussi lment binaire.
e
ee
OCTET n. m. XXe si`cle. Driv savant du latin
e
e e
octo, huit . Unit dinformation compose de huit
e
e
bits.
Programmation
Un algorithme exprime la structure logique dun programme informatique et de ce fait est

indpendant du langage de programmation utilis. Par contre, la traduction de lalgorithme dans
e
e
un langage particulier dpend du langage choisi et sa mise en uvre dpend galement de la
e
e
e
plateforme dexcution.
e
La programmation dun ordinateur consiste ` lui expliquer en dtail ce quil doit faire,
a
e
en sachant quil ne comprend pas le langage humain, mais quil peut seulement eectuer un
traitement automatique sur des squences de 0 et de 1. Un programme nest rien dautre quune
e
suite dinstructions, encodes en respectant de mani`re tr`s stricte un ensemble de conventions
e
e
e
xes ` lavance par un langage informatique (gure 1.6). La machine dcode alors ces instruce a
e
tions en associant ` chaque mot du langage informatique une action prcise. Le programme
a
e
que nous crivons dans le langage informatique ` laide dun diteur (une sorte de traitement de
e
a
e
texte spcialis) est appel programme source (ou code source).
e
e
e
Le seul langage que lordinateur puisse vritablement comprendre est donc tr`s
e
e
loign de ce que nous utilisons nous-mmes. Cest une longue suite de 0 et de 1 (les bits ,
e
e
e
binary digit) traits par groupes de 8 (les octets , byte), 16, 32, ou mme 64 (gure 1.6).
e
e
Dnition 1.11 : bit
e
Un bit est un chire binaire (0 ou 1). Cest lunit lmentaire dinformation.
e ee
Dnition 1.12 : octet
e
Un octet est une unit dinformation compose de 8 bits.
e
e
Fig. 1.7 : Cle USB (Universal Serial Bus)
Dispositif matriel cone

tenant une mmoire de
e
masse (une mmoire
e
ash ou un mini disque
dur).
Exemple 1.3 : Description de cle USB

Sur le descriptif commercial dune cl USB (gure 1.7), on peut lire :
e
Type de produit : Lecteur ash USB
Taille du module : 512 Mo
Type dinterface : Hi-Speed USB
La taille du module est la capacit de stockage de la cl qui vaut ici 512 Mo (mgaoctets). Le
e
e
e
prxe mga est un multiplicateur dcimal qui vaut 106 mais sil est bien adapt au calcul
e
e
e
e
dcimal, il lest moins au calcul binaire car il ne correspond pas ` une puissance enti`re de 2.
e
a
e
x = 106 vaut x = 6 log(10) 19.93. On choisit alors la
En eet, la puissance x de 2 telle que 2
log(2)
puissance enti`re de 2 immdiatement suprieure (220 = 1 048 576) pour dnir le Mo : 1 Mo =

e
e
e
e
1 048 576 octets.
TD1.4
Pour parler ` un ordinateur, il nous faudra donc utiliser des syst`mes de traduction
a
e
automatiques, capables de convertir en nombres binaires des suites de caract`res formant des
e
mots-cls (anglais en gnral) qui seront plus signicatifs pour nous. Le syst`me de traduction
e
e e
e
proprement dit sappellera interprteur ou bien compilateur, suivant la mthode utilise pour
e
e
e
eectuer la traduction (gure 1.8).
TD 1.4 : Unites dinformation

Combien y a-t-il doctets dans 1 ko (kilooctet), 1 Go (gigaoctet), 1 To (traoctet), 1 Po (ptaoctet), 1 Eo (exaoce
e
tet), 1 Zo (zettaoctet) et 1 Yo (yottaoctet) ?
Dnition 1.13 : compilateur

e
Un compilateur est un programme informatique qui traduit un langage, le langage source, en un
autre, appel le langage cible.
e
Dnition 1.14 : interpreteur

e
Un interprteur est un outil informatique (logiciel ou matriel) ayant pour tche danalyser et
e
e
a
dexcuter un programme crit dans un langage source.
e
e
On appellera langage de programmation un ensemble de mots-cls (choisis arbitrairement)
e
associ ` un ensemble de r`gles tr`s prcises indiquant comment on peut assembler ces mots
e a
e
e
e
pour former des phrases que linterprteur ou le compilateur puisse traduire en langage
e
machine (binaire). Un langage de programmation se distingue du langage mathmatique par
e
sa vise oprationnelle (ie. il doit tre excutable par une machine), de sorte quun langage
e
e
e
e
de programmation est toujours un compromis entre sa puissance dexpression et sa possibilit
e
dexcution.
e
Dnition 1.15 : langage de programmation
e
Un langage de programmation est un langage informatique, permettant ` un humain dcrire un
a
e
code source qui sera analys par un ordinateur.
e
Le code source subit ensuite une transformation ou une valuation dans une forme exploitable
e
par la machine, ce qui permet dobtenir un programme. Les langages permettent souvent de faire
abstraction des mcanismes bas niveaux de la machine, de sorte que le code source reprsentant
e
e
une solution puisse tre rdig et compris par un humain.
e
e e
Dnition 1.16 : programmation
e
La programmation est lactivit de rdaction du code source dun programme.
e
e
Fig. 1.8 : Du code source a son execution

compilation
interprtation
semicompilation
ADA, C/C++, Fortran
Lisp, Prolog
Java, Python
code source
code source
code source
compilateur
code objet
compilateur
interprteur
excuteur
rsultat
bytecode
interprteur
rsultat
rsultat
10

Compilation : La compilation consiste ` traduire la totalit du code source en une fois. Le

a
e
compilateur lit toutes les lignes du programme source et produit une nouvelle suite de
codes appel programme objet (ou code objet). Celui-ci peut dsormais tre excut
e
e
e
e e
indpendamment du compilateur et tre conserv tel quel dans un chier ( chier excue
e
e
e
table ). Les langages Ada, C, C++ et Fortran sont des exemples de langages compils.
e
Interprtation : Linterprtation consiste ` traduire chaque ligne du programme source en
e
e
a
quelques instructions du langage machine, qui sont ensuite directement excutes au fur
e e
et ` mesure ( au l de leau ). Aucun programme objet nest gnr. Linterprteur doit
a
e ee
e
tre utilis chaque fois que lon veut faire fonctionner le programme. Les langages Lisp et
e
e
Prolog sont des exemples de langages interprts.
ee
Linterprtation est idale lorsque lon est en phase dapprentissage du langage, ou en
e
e
cours dexprimentation sur un projet. Avec cette technique, on peut en eet tester
e
immdiatement toute modication apporte au programme source, sans passer par une
e
e
phase de compilation qui demande toujours du temps. Mais lorsquun projet comporte des
fonctionnalits complexes qui doivent sexcuter rapidement, la compilation est prfrable :
e
e
ee
un programme compil fonctionnera toujours plus vite que son homologue interprt,
e
ee
puisque dans cette technique lordinateur na plus ` (re)traduire chaque instruction en
a
code binaire avant quelle puisse tre excute.
e
e e
Semi-compilation : Certains langages tentent de combiner les deux techniques an de retirer
le meilleur de chacune. Cest le cas des langages Python et Java par exemple. De tels
langages commencent par compiler le code source pour produire un code intermdiaire,
e
similaire ` un langage machine (mais pour une machine virtuelle), que lon appelle bya
tecode, lequel sera ensuite transmis ` un interprteur pour lexcution nale. Du point
a
e
e
de vue de lordinateur, le bytecode est tr`s facile ` interprter en langage machine. Cette
e
a
e
interprtation sera donc beaucoup plus rapide que celle dun code source.
e
Le fait de disposer en permanence dun interprteur permet de tester immdiatement nime
e
porte quel petit morceau de programme. On pourra donc vrier le bon fonctionnement de
e
chaque composant dune application au fur et ` mesure de sa construction. Linterprtation
a
e
du bytecode compil nest pas aussi rapide que celle dun vritable code machine, mais elle
e
e
est satisfaisante pour de tr`s nombreux programmes.
e
Python : www.python.org
Dans ce cours, nous choisirons dexprimer directement les algorithmes dans un langage informatique oprationnel : le langage Python [16], sans passer par un langage algorithmique
e
intermdiaire.
e
1.2. OBJECTIFS DU COURS
1.2
1.2.1
11
Objectifs du cours
Objectifs thmatiques
e
Lobjectif principal des enseignements dinformatique S1 de lENIB est lacquisition des notions fondamentales de lalgorithmique. Plus prcisment, nous tudierons successivement :
e e
e
1. les instructions de base permettant de dcrire les algorithmes : aectation, tests, boucles ;
e
2. les procdures et les fonctions qui permettent de structurer et de rutiliser les algorithmes ;
e
e
on parlera alors dencapsulation, de prconditions, de porte des variables, de passage de
e
e
param`tres, dappels de fonctions, de rcursivit et de jeux de tests ;
e
e
e
3. les structures de donnes linaires : tableaux, listes, piles, les, qui amliorent la struce
e
e
turation des donnes manipules par les algorithmes. A cette occasion, on valuera la
e
e
e
complexit et lecacit de certains algorithmes utilisant ces structures linaires.
e
e
e
Ces direntes notions seront mise en uvre ` travers lutilisation du langage Python.
e
a
1.2.2
`
TD 1.5 : Premiere utilisation de Python
Se connecter sur un poste de travail dune salle informatique.
1. Lancer Python.
2. Utiliser Python comme une simple calculette.
3. Quitter Python.
Ne pas oublier de se dconnecter du poste de travail.
e
TD1.5
Objectifs pdagogiques
e
Au cours du semestre S1, nous nous positionnerons principalement sur les 3 premiers niveaux
de la taxonomie de Bloom qui constitue une rfrence pdagogique pour la classication des
ee
e
niveaux dapprentissage (gure 1.9) : connaissance, comprhension, application. Les 3 derniers
e
niveaux seront plutt abords au cours du semestre S2 (analyse, synth`se, valuation).
o
e
e e
1. Connaissance : mmorisation et restitution dinformations dans les mmes termes.
e
e
2. Comprhension : restitution du sens des informations dans dautres termes.
e
3. Application : utilisation de r`gles, principes ou algorithmes pour rsoudre un probl`me,
e
e
e
les r`gles ntant pas fournies dans lnonc.
e
e
e
e
4. Analyse : identication des parties constituantes dun tout pour en distinguer les ides.
e
5. Synth`se : runion ou combinaison des parties pour former un tout.
e
e
6. Evaluation : formulation de jugements qualitatifs ou quantitatifs.
An de mieux nous situer par rapport aux dirents types de pdagogie associs, nous
e
e
e
lerons une mtaphore musicale inspire de [3].
e
e
Fig. 1.9 : Taxonomie de Bloom

Benjamin Bloom (1913-1999), psychologue amrie
cain spcialis en pdagogie.
e
e
e
Conna
tre
: dnir, distinguer, acqurir, identier,

e
e
rappeler, reconna
tre. . .
Comprendre : traduire, illustrer, reprsenter, dire
e
avec ses mots, distinguer, rcrire,
ee
rarranger, expliquer, dmontrer. . .
e
e
Appliquer : appliquer, gnraliser, relier, choie e
sir, dvelopper, utiliser, employer,
e
transfrer, classer, restructurer. . .
e
Analyser
: distinguer, dtecter, classer, ree
conna
tre, catgoriser, dduire, discere
e
ner, comparer. . .
Synthtiser : crire, relater, produire, constituer,
e
e
transmettre, modier, crer, proposer,
e
planier, projeter, spcier, combiner,
e
classer, formuler. . .
Evaluer
: juger, argumenter, valider, dcider,
e
comparer. . .

12
Remarque 1.1 : Lannexe A page 207 prsente quele

ques grands classiques historiques . On trouvera
galement une liste dalgorithmes classiques sur le site du
e
National Institute of Standards and Technology (NIST :
www.nist.gov/dads).
Pdagogie par objectifs : Le solf`ge est ltude des principes lmentaires de la musique et
e
e
e
ee
de sa notation : le musicien fait ses gammes et chaque exercice a un objectif prcis
e
pour valuer lapprentissage du langage musical . Il en va de mme pour linformaticien
e
e
dbutant confront ` lapprentissage dun langage algorithmique.
e
ea
Pdagogie par lexemple : Lapprentissage des grands classiques permet au musicien de sape
proprier les bases du solf`ge en les appliquant ` ces partitions connues et en les (re)jouant
e
a
lui-mme. Linformaticien dbutant, en (re)codant lui-mme des algorithmes bien connus,
e
e
e
se constituera ainsi une base de rexes de programmation en imitant ces algorithmes.
e
Pdagogie de lerreur : Les bogues (bugs) sont ` linformaticien ce que les fausses notes sont
e
a
aux musiciens : des erreurs. Ces erreurs sont ncessaires dans lacquisition de la connaise
sance. Un l`ve a progress si, apr`s stre tromp, il peut reconna quil sest tromp,
ee
e
e e
e
tre
e
dire o` et pourquoi il sest tromp, et comment il recommencerait sans produire les mmes
u
e
e
erreurs.
Pdagogie par probl`mes : Connaissant ses classiques et les bases du solf`ge, le musicien
e
e
e
devenu plus autonome peut envisager sereinement la cration de ses propres morceaux. Le
e
dveloppement dun projet informatique ambitieux sera mis en musique au semestre
e
S2.
Dans ce cours, nous adopterons ces direntes stratgies pdagogiques sans oublier quen
e
e
e
informatique on apprend toujours mieux en faisant par soi-mme.
e
1.2.3
Objectifs comportementaux
Nous cherchons ` dvelopper trois qualits comportementales chez linformaticien dbua e

e
e
tant : la rigueur, la persvrance et lautonomie.
e e
Rigueur : Un ordinateur est une machine qui excute vite et bien les instructions quon lui
e
a apprises . Mais elle ne sait pas interprter autre chose : mme mineure, une erreur
e
e
provoque le dysfonctionnement de la machine.
Exemple 1.4 : Erreur de syntaxe en langage C
Pour un ; oubli dans un programme C, le code source nest pas compilable et le come
pilateur nous avertit par ce type de message :
fichier.c : In function main :
fichier.c :7 : error : syntax error before "printf"
1.3. ORGANISATION DU COURS
13
Mme si un humain peut transiger sur le ; , la machine ne le peut pas : lordinateur ne

e
se contente pas de l ` peu pr`s . La respect des consignes, la prcision et lexactitude
a
e
e
sont donc de rigueur en informatique !
TD1.6
Persvrance : Face ` lintransigeance de la machine, le dbutant est confront ` ses nome e
a
e
ea
breuses erreurs (les siennes, pas celles de la machine !) et sa tendance naturelle est de passer
a
` autre chose. Mais le papillonnage (ou zapping) est une tr`s mauvaise stratgie en infore
e
matique : pour sexcuter correctement, un programme doit tre nalis. Linformatique
e
e
e
ncessite d aller au bout des choses .
e
TD1.7
Autonomie : Programmer soi-mme les algorithmes quon a dnis est sans doute le meilleur
e
e
moyen pour mieux assimiler les principales structures algorithmiques et pour mieux comprendre ses erreurs en se confrontant ` lintransigeante impartialit de lordinateur, vritaa
e
e
ble juge de paix des informaticiens. Par ailleurs, lvolution continuelle et soutenue des
e
langages de programmation et des ordinateurs ncessitent de se tenir ` jour rguli`rement
e
a
e
e
et seule lautoformation systmatique permet de ne pas perdre pied .
e
TD1.8
Pratique personnelle et autoformation constituent ainsi deux piliers de lautonomisation
ncessaire de lapprenti informaticien.
e
1.3
1.3.1
Organisation du cours

TD 1.7 : Dessins sur la plage : perseverance
Finir lalgorithme suivant qui cherche ` dessiner un loa
sange sur la plage.
a
.
.
.
TD 1.8 : Autonomie
Trouver les dnitions du mot autonomie et de son
e
contraire (de son antonyme).
Prsentiel
e
Les enseignements dinformatique S1 de lENIB sont dispenss lors de 42h de sances de

e
e
cours-TD et de sances de laboratoire.
e
Les cours-TD ont lieu 1 semaine sur 2 ` raison de 3h par semaine, soit 21h de cours-TD
a
sur toute la dure du semestre. Ils se droulent dans une salle banalise.
e
e
e
Les sances de laboratoire ont lieu 1 semaine sur 2 en alternance avec les cours-TD `
e
a
raison de 3h par semaine, soit 21h de laboratoire dans le semestre. Elles se droulent en
e
salle informatique.
1.3.2
TD 1.6 : Erreur de syntaxe en Python

On consid`re la session Python suivante :
e
>>> x = 3
>>> y = x
File "<stdin>", line 1
y = x
^
SyntaxError : invalid syntax
>>>
De quelle erreur de syntaxe sagit-il ?
Documents
Les principaux documents accompagnant les cours sont de 2 types : les supports de cours et
les notes de cours.
Remarque 1.2 : Un semestre stale sur 14 semaines

e
denseignements, 7 semaines consacres au cours et 7
e
semaines aux TD.
14
Support de cours : il sagit de la copie papier des transparents projets en prsentiel (gure
e
e
1.10).
Fig. 1.10 : Transparent de cours
Notes de cours : il sagit de notes qui compl`tent et prcisent certains points prsents en
e
e
e
e
cours. Ces notes proposent galement les exercices de travaux dirigs qui sont tudis en
e
e
e
e
cours et au laboratoire. Le document que vous tes en train de lire constitue le premier
e
chapitre des notes du cours dinformatique S1 de lENIB. Il y en aura 3 autres sur les
sujets suivants :
Informatique
Dnition
e
information automatique

(P. Dreyfus, 1962)
informatique : science du traitement automatique de

linformation
1. les instructions de base (chapitre 2 page 39),
Matriel Logiciel
e
matriel : ordinateurs
e
(J. Perret, 1955)
2. les procdures et les fonctions (chapitre 3 page 99),

e
3. les structures de donnes linaires (chapitre 4 page 157).
e
e
logiciel : ensemble de programmes remplissant une fonction

dtermine, permettant laccomplissement dune tche donne
e
e
a
e
tisseau@enib.fr
Algorithmique
enib c 2009
2/18
TD 1.9 : Site Web dInformatique S1

Se connecter sur le site Web du cours dinformatique S1
de lENIB et vrier que ces notes de cours sont bien
e
disponibles sur le site au format pdf.
Un site Web permet de retrouver ces documents au format pdf (Portable Document Format)
ainsi que dautres documents tels que le planning prvisionnel des cours et des contrles, des
e
o
exemples corrigs dvaluation, les notes aux dirents contrles ou encore des liens vers des
e
e
e
o
sites pertinents pour le cours. Un forum de discussions professeursl`ves est galement ouvert
ee
e
sur ce site.
TD1.9
La consultation rguli`re du site est indispensable pour se tenir au courant des derni`res
e
e
e
volutions du cours : en cas dambigu e, ce sont les informations de ce site qui feront foi.
e
t
1.3.3
Evaluations des apprentissages
Lvaluation des connaissances et des comptences acquises par les tudiants repose sur 4
e
e
e
types de contrle : les contrles dattention, les contrles de TD, les contrles dautoformation
o
o
o
o
et les contrles de comptences.
o
e
TD 1.10 : Exemple de controle dattention (1)

Rpondre de mmoire aux questions suivantes (ie. sans
e
e
rechercher les solutions dans les pages prcdentes).
e e
1. Quels sont les 3 principaux th`mes informatiques
e
abords ?
e
2. Quelles sont les 4 principales stratgies pdagoe
e
giques suivies ?
3. Quelles sont les 3 principales qualits comportee
mentales recherches ?
e
Contrle dattention : il sagit dun QCM (questionnaire ` choix multiples) auquel il faut
o
a
rpondre individuellement sans document, en 5 en n de cours, et dont les questions
e
portent sur des points abords pendant ce cours. Ce type de contrle teste directement
e
o
lacquisition de connaissances au sens du conna de la classication de Bloom (section
tre
1.2.2 page 11). Il permet dvaluer ` chaud la capacit dattention des tudiants et les
e
a
e
e
incite ` une prsence attentive an de bncier au maximum des heures de prsence aux
a
e
e e
e
cours.
TD1.10
Des exemples de QCM sont systmatiquement proposs dans les notes de cours comme
e
e
par exemple celui du TD 1.19 page 20 pour cette introduction gnrale.
e e
1.3. ORGANISATION DU COURS
15
Contrle de TD : il sagit ici dinciter les tudiants ` prparer activement les sances de
o
e
a e
e
laboratoire. En dbut de chaque sance de laboratoire, chaque binme doit rpondre sans
e
e
o
e
document en 10 aux questions dun exercice de TD. Lexercice est choisi alatoirement
e
parmi les exercices de TD situs en marge des notes de cours et se rapportant au th`me
e
e
du TD.
TD1.11
Il concerne le comprendre et l appliquer de la taxonomie de Bloom (section 1.2.2
page 11).
Contrle dautoformation : un contrle dautoformation porte sur un th`me prvu ` lavance
o
o
e
e a
et que ltudiant doit approfondir par lui-mme. Les th`mes retenus pour lautoformation
e
e
e
en S1 sont par exemple le calcul boolen, le codage des nombres ou encore la recherche
e
dlments dans un tableau de donnes.
ee
e
TD1.12
Ces contrles se droulent pendant les sances de cours : ce sont des crits individuels de
o
e
e
e
30 sans document qui concernent le conna , le comprendre et l appliquer
tre
de la taxonomie de Bloom.
Contrle de comptences : les contrles de comptences (ou DS) durent 80 pendant une
o
e
o
e
sance de cours. Plus longs, ils permettent daborder lun des 3 derniers niveaux de la
e
classication de Bloom (analyser, synthtiser, valuer) comme le font les exercices de la
e
e
section 1.5.4 page 23.
TD1.13
Quel que soit le type de contrle, un exercice cherche ` valuer un objectif particulier. Aussi, la
o
ae
notation exprimera la distance qui reste ` parcourir pour atteindre cet objectif (gure 1.11) :
a
0
1
2
3
:
:
:
:
en plein dans le mille !

pas mal !
juste au bord de la cible !
la cible nest pas touche !
e
lobjectif est atteint

on se rapproche de lobjectif
on est encore loin de lobjectif
lobjectif nest pas atteint
Ainsi, et pour changer de point de vue sur la notation, le contrle est russi lorsquon a 0 ! Il
o
e
ny a pas non plus de 1/2 point ou de 1/4 de point : le seul barme possible ne comporte que 4
e
niveaux : 0, 1, 2 et 3. On ne cherche donc pas ` grappiller des points :
a
on peut avoir 0 (objectif atteint) et avoir fait une ou deux erreurs bnignes en regard de
e
lobjectif recherch ;
e
on peut avoir 3 (objectif non atteint) et avoir quelques lments de rponse corrects mais
ee
e
sans grand rapport avec lobjectif.
TD 1.11 : Exemple de controle de TD

Rpondre aux questions du TD 1.10 situ dans la marge
e
e
de la page 14.
TD 1.12 : Exemple de controle dautoformation (1)

Etablir la table de vrit du circuit logique ci-dessous o`
e e
u
a, b et c sont les entres, s et t les sorties.
e
a
b
c
TD 1.13 : Exemple de controle des competences

Rpondre aux questions du TD 1.28 de la page 25.
e
Fig. 1.11 : Metaphore de la cible
0
1
2
3
Remarque 1.3 : Une absence ` un contrle conduit `
a
o
a
la note 4 ( la cible nest pas vise ).
e

16
1.3.4
Evaluation des enseignements
En n de semestre, les tudiants organisent de mani`re anonyme et dans le respect des

e
e
personnes, une valuation individuelle des enseignements. Elle est structure en 2 parties : un
e
e
questionnaire de 10 ` 20 questions (voir un exemple en annexe 1.6.2 page 33) auxquelles il faut
a
rpondre selon une grille pr-dnie et une partie expression libre que ltudiant remplit, ou
e
e e
e
non, ` son gr.
a
e
Lensemble des ches dvaluation est remis ` lquipe pdagogique dInformatique S1, qui
e
a e
e
apr`s en avoir pris connaissance, organise une rencontre spcique avec les tudiants. Cette
e
e
e
valuation a pour objectif lamlioration de la qualit des enseignements et de la pdagogie `
e
e
e
e
a
partir de la perception quen ont les tudiants.
e
1.4
Remarque 1.4 : Ce document comporte 259 pages
structures en 4 chapitres, 3 annexes, 4 index et une
e
bibliographie. Il propose 47 dnitions, 86 gures, 39
e
exemples, 79 remarques, 128 exercices et 5 contrles types
o
corrigs. En moyenne, au cours des 14 semaines que dure
e
le cours dinformatique S1 de lENIB, le travail personnel
hebdomadaire consiste donc ` lire entre 15 et 20 pages de
a
ce cours en retenant 3 ` 4 dnitions et en faisant entre
a
e
7 et 10 exercices.
TD 1.14 : Nombre de controles

Apr`s consultation du calendrier prvisionnel de lannexe
e
e
1.6.3 page 34, donner le nombre et le type de contrles
o
prvus au calendrier du semestre.
e
Mthodes de travail
e
Il ne sagit pas ici dimposer des mthodes de travail, mais de fournir des pistes pour ceux
e
qui en cherchent. Dans tous les cas, lexprience montre que :
e
1. la seule prsence, mme attentive et active, aux sances de cours et de laboratoire ne sut
e
e
e
pas : il faut prvoir un temps de travail personnel qui, selon ltudiant et la mati`re, peut
e
e
e
aller de 50% ` 150% du temps de prsence en cours ;
a
e
2. la rgularit dans le travail personnel est un gage dapprentissage plus ecace.
e
e
Le calendrier prvisionnel des enseignements et des contrles associs est distribu en dbut de
e
o
e
e
e
semestre (un exemple de planning est donn en annexe 1.6.3 page 34).
e
TD1.14
Les documents de cours sont distribus au moins 15 jours avant les sances correspondantes
e
e
(sauf en ce qui concerne les 2 premi`res semaines de cours videmment). Par ailleurs, ` tout
e
e
a
moment, le calendrier et les documents sont disponibles sur le site Web dInformatique S1.
1.4.1
Avant, pendant et apr`s le cours

e
Prparation : Certains cours dbutent par un contrle dautoformation (voir section 1.3.3)
e
e
o
dont le th`me est en rapport avec certains aspects du cours qui suivra immdiatement. Il
e
e
est donc ncessaire davoir tudi avant et par soi-mme le sujet du contrle.
e
e
e
e
o
En gnral, on trouvera les informations ncessaires soit directement sur le site dInformae e
e
tique S1, soit dans les rfrences bibliographiques donnes en n des notes de cours (voir
ee
e

1.4. METHODES DE TRAVAIL
17
par exemple les rfrences de ce chapitre en page 271), soit dans les polycopis dautres
ee
e
cours de lENIB (mathmatiques, lectronique, productique, microprocesseurs. . .), soit ene
e
core sur internet en sassurant de la qualit du site (prfrer des sites universitaires ou
e
ee
dcoles dont lactivit principale est denseigner ces mati`res).
e
e
e
Par exemple, il est ncessaire davoir assimil les principes du calcul boolen pour ma
e
e
e
triser
les tests et les boucles du langage algorithmique. Cest pourquoi, une autoformation est
impose sur ce domaine dj` connu des tudiants. Un contrle-type dautoformation sur le
e
ea
e
o
calcul boolen pourrait par exemple tre compos des TD 1.12 page 15 et 1.15 ci-contre.
e
e
e
TD1.15
Pour chaque contrle dautoformation, un exemple corrig est disponible sur le site dInforo
e
matique S1. Il est donc fortement recommand de travailler ce contrle-type : apr`s avoir
e
o
e
revu par soi-mme les principales notions du domaine, faire le contrle sans consulter au
e
o
pralable la solution propose.
e
e
Participation : Par respect pour les autres participants, la ponctualit est de rigueur pour
e
ltudiant comme pour le professeur. Mais assister ` un cours na dintrt que dans le cas
e
a
ee
dune prsence attentive et soutenue : le temps pass en cours pour assimiler les nouvelles
e
e
notions sera gagn sur le temps de travail personnel futur ncessaire ` leur assimilation.
e
e
a
Chaque page des supports de cours est constitue dune copie dun transparent de cours
e
dans la demi-page suprieure alors que la demi-page infrieure est volontairement laisse
e
e
e
vierge pour que ltudiant prenne des notes pendant le cours (gure 1.12).
e
La prise de note systmatique est en eet un facteur qui favorise lattention. Un contrle de
e
o
type QCM en n de cours valuera lattention des tudiants (voir section 1.3.3). TD1.16
e
e
Le cours est illustr par des exemples et des exercices : ` ces occasions, cest une particie
a
pation active de ltudiant qui est attendue dans une dmarche volontaire dassimilation
e
e
du cours ` chaud .
a
Appropriation : Dans la mesure du possible, il faut relire ses propres notes ainsi que les notes
de cours le soir mme an de xer les principales ides du cours. La rvision propree
e
e
ment dite peut venir ultrieurement quelques jours plus tard (et non quelques semaines ni
e
quelques mois apr`s).
e
Les dnitions, comme toute dnition, sont ` apprendre par cur . Une technique pose
e
a
sible est de lire 2 fois de suite ` voix haute la dnition en dtachant distinctement les
a
e
e
direntes expressions (exemple : linformatique est la science du traitement
e
automatique de linformation ), puis lcrire de mmoire.
e
e
TD 1.15 : Exemple de controle dautoformation (2)

Exprimer en la dveloppant la ngation des expressions
e
e
boolennes suivantes :
e
1. (0 < x) and (x < 3)
2. (x < -2) or (x > 4)
3. a and (not b)
4. (not a) or b
TD 1.16 : Exemple de controle dattention (2)

Rpondre de mmoire aux questions suivantes (ie. sans
e
e
rechercher les solutions dans les pages prcdentes).
e e
1. Quels sont les 4 types de contrle proposs ?
o
e
2. Quels sont les documents que lon peut trouver sur
le site Web du cours ?
Fig. 1.12 : Support de cours
Informatique
Dnition
e
information automatique
(P. Dreyfus, 1962)
informatique : science du traitement automatique de linformation
Matriel Logiciel
e
matriel : ordinateurs
e
(J. Perret, 1955)
logiciel : ensemble de programmes remplissant une fonction dtermine,

e
e
permettant laccomplissement dune tche donne
a
e
Algorithmique
tisseau@enib.fr
enib c 2009
2/18
,
Dnitions
e
informatique Linformatique est la science du traitement automatique de
linformation.
matriel Le matriel informatique est un ensemble de dispositifs physiques
e
e
utiliss pour traiter automatiquement des informations.
e
logiciel Le logiciel est un ensemble structur dinstructions dcrivant un
e
e
traitement dinformations ` faire raliser par un matriel
a
e
e
informatique.
Remarque (Cours Informatique S1)

Dans ce cours, nous ne nous intresserons quaux aspects logiciels de
e
linformatique.

18
Pour rviser le cours, faire systmatiquement les TD au moment o` ils sont rfrencs dans
e
e
u
ee
e
les notes par le symbole
. Cest particuli`rement vrai avec les exemples pour lesquels
e
sont associs des exercices en marge des notes de cours (exemple : lexemple 1.1 de la page
e
5 et le TD 1.1 associ en marge de la mme page). Lorsque lexemple est un algorithme, il
e
e
faut systmatiquement se mettre mentalement ` la place de la machine qui va les excuter
e
a
e
(on parle alors d empathie numrique ) an de vrier le rsultat obtenu. Pour cela, il
e
e
e
faut tre mthodique et rigoureux. Et petit ` petit, ` force de pratique, lexprience fera
e
e
a
a
e
quon verra le rsultat produit par les instructions au fur et ` mesure quon les crit.
e
a
e
Naturellement, cet apprentissage est long, et demande des heures de travail patient. Aussi,
dans un premier temps, il faut viter de sauter les tapes : la vrication mthodique, pas
e
e
e
e
a
` pas, de chacun des algorithmes reprsente plus de la moiti du travail ` accomplir [5].
e
e
a
1.4.2
TD 1.17 : Nombres dexercices de TD
Combien dexercices y avait-il ` faire avant celui-ci ?
a
TD 1.18 : Environnement de travail

Sur un poste de travail dune salle informatique :
1. Quel est le type de clavier ?
2. Comment ouvre-t-on un terminal ?
3. Comment lance-t-on Python ?
4. O` sont stocks les chiers de travail ?
u
e
Avant, pendant et apr`s le laboratoire

e
Prparation : Faire les exercices situs dans les marges de ces notes de cours est non seulement
e
e
une faon de rviser son cours (voir section 1.4.1) mais aussi de prparer les sances de
c
e
e
e
laboratoire. Pour ces notes de cours, la liste compl`te des exercices est donne en annexe
e
e
B page 223. Un de ces exercices choisi alatoirement fera lobjet dune valuation en dbut
e
e
e
de chaque sance de TD (voir section 1.3.3).
e
TD1.17
Tous ces exercices ne ncessitent pas une longue phase de rexion comme les TD 2.7 ou
e
e
1.13 ( 1.28). Certains au contraire ne prsentent aucune dicult particuli`re comme
e
e
e
les TD 1.14 et 1.17 qui demandent simplement de compter les contrles et les exercices.
o
Dautres comme les TD 1.10 et 1.16 font appel ` la mmoire, dautres encore ` la recherche
a
e
a
dinformations comme les TD 1.4 et 1.8, ou ` une mise en uvre pratique comme les TD
a
1.5 et 1.9.
Participation : Ici encore, par respect pour les autres participants, la ponctualit est de
e
rigueur pour ltudiant comme pour le professeur.
e
En informatique, lorsquon travaille en binme, il faut rguli`rement alterner les rles entre
o
e
e
o
l crivain qui manipule clavier et souris et le lecteur qui vrie la production de
e
e
lcrivain. A la n du semestre, chaque tudiant doit tre devenu un lecteur-crivain .
e
e
e
e
La pratique est en eet ncessaire pour apprivoiser lenvironnement de travail an
e
que la machine devienne transparente et que seul subsiste le probl`me algorithmique
e
a e
` rsoudre.
TD1.18

1.4. METHODES DE TRAVAIL
19
Pour certains exercices, la solution est donne dans les notes de cours (en section 1.5.5
e
page 26 pour ce chapitre). Pendant les sances de laboratoire, il faut donc savoir jouer le
e
jeu pour ne pas simplement recopier la solution propose (il existe dailleurs dautres
e
solutions pour la plupart des exercices).
Un apprenti programmeur est toujours confront ` ses propres erreurs (revoir le TD 1.6
ea
page 13 par exemple). En gnral, ce sont des erreurs simples ` corriger ` condition de lire
e e
a
a
les messages derreur et de faire leort de les comprendre avant dappeler le professeur
` laide .
a
Exemple 1.5 : Erreur de nom en Python
Voici une erreur classique dune variable non correctement initialise en Python :
e
>>> print(x)
Traceback (most recent call last) :
File "<stdin>", line 1, in ?
NameError : name x is not defined
>>>
En Python, la derni`re ligne du message derreur est la plus parlante au dbutant.
e
e
Appropriation : Avant le cours suivant, il faut refaire les TD qui ont pos des probl`mes et
e
e
faire les exercices qui nont pas pu tre abords en sance de laboratoire (les solutions de
e
e
e
ces exercices complmentaires sont donnes dans les notes de cours).
e
e
1.4.3
Apprendre en faisant
1. En bas de la page 17, il est dit :

Les dnitions, comme toute dnition, sont ` apprendre par cur.
e
e
a
Connaissez-vous les 16 dnitions introduites dans ce chapitre ? Elles sont clairement idene
tiables grce au mot-cl Dnition .
a
e
e
2. En haut de la page 18, il est dit :
Pour rviser le cours, faire systmatiquement les TD au moment o` ils sont
e
e
u
rfrencs dans les notes par le symbole .
ee
e
Avez-vous cherch ` rsoudre les 18 exercices de TD proposs jusqu` prsent ? Ils sont
e a e
e
a e
clairement identiables grce au mot-cl TD situ dans la marge.
a
e
e
Il ny a pas de miracle, cest votre travail personnel qui est le meilleur gage de vos apprentissages.
On apprend toujours mieux en faisant par soi-mme.
e
Remarque 1.5 : La derni`re phrase de cette section a

e
dj` t crite dans le texte qui prc`de. A propos de
ea ee e
e e
quoi ? En quelle page ?

20
1.5
1.5.1
Exercices complmentaires
e
Conna
tre
TD 1.19 : QCM (1)

(un seul item correct par question)
Remarque 1.6 : Parmi les 4 items de la question cicontre, un seul item dnit linformatique, les 3 autres
e
dnissent dautres sciences. Lesquelles ?
e
1. Linformatique est la science

(a) des dispositifs dont le fonctionnement dpend de la circulation dlectrons
e
e
(b) des signaux lectriques porteurs dinformation ou dnergie
e
e
(c) du traitement automatique de linformation
(d) de la commande des appareils fonctionnant sans intervention humaine
2. Le logiciel est
(a) la mmoire de lordinateur
e
(b) le traitement automatique de linformation
(c) lensemble des donnes manipules par les instructions
e
e
(d) un ensemble structur dinstructions dcrivant un traitement dinformations ` faire
e
e
a
raliser par un matriel informatique
e
e
3. Lalgorithmique est la science
(a) du traitement automatique de linformation
(b) des algorithmes
(c) des langages de programmation
(d) des instructions
4. Un algorithme est
(a) un ensemble de programmes remplissant une fonction dtermine, permettant lace
e
complissement dune tche donne
a
e
(b) une suite ordonne dinstructions qui indique la dmarche ` suivre pour rsoudre une
e
e
a
e
srie de probl`mes quivalents
e
e
e
(c) le nombre dinstructions lmentaires ` excuter pour raliser une tche donne
ee
a e
e
a
e
(d) un ensemble de dispositifs physiques utiliss pour traiter automatiquement des infore
mations

1.5. EXERCICES COMPLEMENTAIRES
21
5. La validit dun algorithme est son aptitude

e
(a) ` utiliser de mani`re optimale les ressources du matriel qui lexcute
a
e
e
e
(b) ` se protger de conditions anormales dutilisation
a
e
(c) ` calculer le nombre dinstructions lmentaires ncessaires pour raliser la tche
a
ee
e
e
a
pour laquelle il a t conu
ee
c
(d) ` raliser exactement la tche pour laquelle il a t conu
a e
a
ee
c
6. La complexit dun algorithme est
e
(a) le nombre de fois o` lalgorithme est utilis dans un programme
u
e
(b) le nombre de donnes manipules par les instructions de lalgorithme
e
e
(c) le nombre doctets occups en mmoire par lalgorithme
e
e
(d) le nombre dinstructions lmentaires ` excuter pour raliser la tche pour laquelle
ee
a e
e
a
il a t conu
ee
c
7. Un bit est
(a) un chire binaire
(b) compos de 8 chires binaires
e
(c) un chire hxadcimal
e e
(d) un mot dun langage informatique
8. Un compilateur
(a) excute le code source
e
(b) excute le bytecode
e
(c) traduit un code source en code objet
(d) excute le code objet
e
TD 1.20 : Puissance de calcul
Donner lordre de grandeur en instructions par seconde des machines suivantes (voir [6] par
exemple) :
1. le premier micro-ordinateur de type PC,
2. une console de jeu actuelle,
Remarque 1.7 : Parmi les 4 items de la question cicontre, un seul item dnit la validit dun algorithme,
e
e
les 3 autres se rapportent ` dautres proprits des algoa
ee
rithmes. Lesquelles ?

22
3. un micro-ordinateur actuel,
4. Deeper-Blue : lordinateur qui a battu Kasparov aux checs en 1997,
e
5. le plus puissant ordinateur actuel.
Remarque 1.8 :
TD 1.21 : voir aussi TD 1.4
TD 1.21 : Stockage de donnees

Donner lordre de grandeur en octets pour stocker en mmoire (voir [6] par exemple) :
e
1. une page dun livre,
2. une encyclopdie en 20 volumes,
e
3. une photo couleur,
4. une heure de vido,
e
5. une minute de son,
6. une heure de son.
1.5.2
Remarque 1.9 :
Remarque 1.10 :
TD 1.22 : Dessins sur la plage : execution (2)

1. Quelle gure gomtrique dessine-t-on en excutant la suite dinstructions ci-dessous ?
e e
e
(a) avance de 3 pas,
(b) tourne ` gauche dun angle de 90 ,
a
(c) avance de 4 pas,
(d) rejoindre le point de dpart.
e
2. Combien de pas a-t-on fait au total pour rejoindre le point de dpart ?
e
TD 1.23 : Dessins sur la plage : conception (2)
Reprendre le TD 1.2 et illustrer la validit, la robustesse, la rutilisabilit, la complexit et
e
e
e
e
lecacit de lalgorithme propos pour dessiner une spirale rectangulaire.
e
e
1.5.3
Remarque 1.11 :
Comprendre
Appliquer
TD 1.24 : Traces de polygones reguliers

On cherche ` faire dessiner une gure polygonale (gure 1.13) sur la plage ` quelquun qui a les
a
a
yeux bands. Pour cela, on ne dispose que de 2 commandes orales : avancer de n pas en avant
e
(n est un nombre entier de pas) et tourner ` gauche dun angle (rotation sur place de ).
a

23
1. Faire dessiner un pentagone rgulier de 10 pas de ct.

e
oe
2. Faire dessiner un hexagone rgulier de 10 pas de ct.
e
oe
3. Faire dessiner un octogone rgulier de 10 pas de ct.
e
oe
4. Faire dessiner un polygone rgulier de n cts de 10 pas chacun.
e
oe
1.5.4
Fig. 1.13 : Pentagone, hexagone, octogone
Analyser
`
TD 1.25 : La multiplication a la russe
La technique de multiplication dite ` la russe consiste ` diviser par 2 le multiplicateur
a
a
(et ensuite les quotients obtenus), jusqu` un quotient nul, ` noter les restes, et ` multiplier
a
a
a
parall`lement le multiplicande par 2. On additionne alors les multiples obtenus du multiplicande
e
correspondant aux restes non nuls.
Exemple : 68 123 (= 8364)
multiplicande multiplicateur
reste somme partielle
M 2
m 2 m mod 2
123
68
0
(0 123) + 0
246
34
0
(0 246) + 0
492
17
1
(1 492) + 0
984
8
0
(0 984) + 492
1968
4
0 (0 1968) + 492
2
0 (0 3936) + 492
3936
7872
1
1 (1 7872) + 492
68 123 =
8364
Eectuer les multiplications suivantes selon la technique ` la russe .
a
1. 64 96 (= 6144)
2. 45 239 (= 10755)
TD 1.26 : La multiplication arabe
On consid`re ici le texte dIbn al-Banna concernant la multiplication ` laide de tableaux [2].
e
a
Tu construis un quadrilat`re que tu subdivises verticalement et horizontalement en autant de bandes quil y
e
a de positions dans les deux nombres multiplis. Tu divises diagonalement les carrs obtenus, ` laide de diagonales
e
e
a
allant du coin infrieur gauche au coin suprieur droit (gure 1.14).
e
e
Remarque 1.12 :
tique.
La multiplication en Egypte an-
La multiplication ` la
a
russe est une variante
connue dune technique
gyptienne dcrite dans le
e
e
papyrus Rhind (environ
-1650). Le scribe Ahm`s
e
y expose des probl`mes de
e
gomtrie et darithmtique
e e
e
(qui viennent en partie des
Babyloniens) dont cette
technique de multiplication.

24
Fig. 1.14 : Tableau dIbn al-Banna
7
8
8
4
2
7
6
2
4
2
1
0
6
8
4
4
2
1
0
0
8
4
2
3
0
0
0
Fig. 1.15 : Boulier chinois
2
6
3
7
6
1
0
0
2 4
1 2
0 1
Tu places le multiplicande au-dessus du quadrilat`re, en faisant correspondre chacune de ses positions ` une
e
a
a
a
e
colonne1 . Puis, tu places le multiplicateur ` gauche ou ` droite du quadrilat`re, de telle sorte quil descende avec
lui en faisant correspondre galement chacune de ses positions ` une ligne2 . Puis, tu multiplies, lune apr`s lautre,
e
a
e
chacune des positions du multiplicande du carr par toutes les positions du multiplicateur, et tu poses le rsultat
e
e
partiel correspondant ` chaque position dans le carr o` se coupent respectivement leur colonne et leur ligne,
a
e u
en plaant les units au-dessus de la diagonale et les dizaines en dessous. Puis, tu commences ` additionner, en
c
e
a
partant du coin suprieur gauche : tu additionnes ce qui est entre les diagonales, sans eacer, en plaant chaque
e
c
nombre dans sa position, en transfrant les dizaines de chaque somme partielle ` la diagonale suivante et en les
e
a
ajoutant ` ce qui y gure.
a
La somme que tu obtiendras sera le rsultat.
e
En utilisant la mthode du tableau dIbn al-Banna, calculer 63247 124 (= 7842628).

e
TD 1.27 : La division chinoise
Dans sa version actuelle, le boulier chinois se compose dun nombre variable de tringles serties
e
e e
dans un cadre rectangulaire [2]. Sur chacune de ces tringles, deux tages de boules spares par
une barre transversale peuvent coulisser librement (gure 1.15). La notation des nombres repose
sur le principe de la numration de position : chacune des 2 boules du haut vaut 5 units et
e
e
chacune des 5 boules du bas vaut 1 unit. Seules comptent les boules situes dans la rgion
e
e
e
transversale.
Il existe des r`gles spciales de division pour chaque diviseur de 1 ` 9. On consid`re ici les
e
e
a
e
7 r`gles de division par 7 (gure 1.16) :
e
1. qi-yi xia jia san : 7-1 ? ajouter 3 en
dessous !
4. qi-si wu sheng wu : 7-4 ? 5 reste 5 !

5. qi-wu qi sheng yi : 7-5 ? 7 reste 1 !
8017 :
2. qi-er xia jia liu : 7-2 ? ajouter 6 en

dessous !
6. qi-liu ba sheng si : 7-6 ? 8 reste 4 !
3. qi-san si sheng er : 7-3 ? 4 reste 2 !
7. feng-qi jin yi : 7-7 ? 1 mont !

e
Ces r`gles ne sont pas des r`gles logiques, mais de simples procds mnmotechniques indie
e
e e
e
quant ce quil convient de faire selon la situation. Leur nonc dbute par le rappel du diviseur,
e
e e
ici 7, et se poursuit par lnonc du dividende, par exemple 3 : 7-3. Le reste de la r`gle indique
e
e
e
1
Lcriture du nombre seectue de droite ` gauche (exemple : 352 scrira donc 253).
e
a
e
Lcriture du nombre seectue de bas en haut (exemple :

e
3
5
2
scrira donc
e
2
5
3
).

25
quelles manipulations eectues, ajouts ou retraits de boules. Il faut galement savoir que le die
e
vidende tant pos sur le boulier, on doit appliquer les r`gles aux chires successifs du dividende,
e
e
e
en commenant par celui dont lordre est le plus lev. ajouter en dessous veut dire mettre
c
e e
des boules au rang immdiatement infrieur (` droite) au rang considr et monter veut
e
e
a
e e
dire mettre des boules au rang immdiatement suprieur (` gauche) au rang considr .
e
e
a
e e
Pour eectuer la division dun nombre par 7, on pose le dividende ` droite sur le boulier et
a
le diviseur (7) ` gauche. On op`re sur les chires successifs du dividende en commenant par
a
e
c
celui dordre le plus lev (le plus ` gauche). Les r`gles prcdemment nonces sont appliques
e e
a
e
e e
e
e
e
systmatiquement.
e
Utiliser un boulier chinois pour diviser 1234 par 7 (1234 = 176 7 + 2).
1
0 0 0 0
1
0 1 1 0
2
1 2 3 4
2
1 2 1 2
TD 1.28 : Le calcul Shadok
Les cerveaux des Shadoks avaient une capacit tout ` fait limite [15]. Ils ne comportaient en
e
a
e
tout que 4 cases. Comme ils navaient que 4 cases, videmment les Shadoks ne connaissaient pas
e
plus de 4 mots : ga, bu, zo et meu (gure 1.17). Etant donn quavec 4 mots, ils ne pouvaient
e
pas compter plus loin que 4, le Professeur Shadoko avait rform tout a :
e
e
c
Quand il ny a pas de Shadok, on dit ga et on crit ga.
e
Quand il y a un Shadok de plus, on dit bu et on crit bu.
e
Quand il y a encore un Shadok, on dit zo et on crit zo.
e
Et quand il y en a encore un autre, on dit meu et on crit meu.
e
Tout le monde applaudissait tr`s fort et trouvait a gnial sauf le Devin Plombier qui disait
e
c e
quon navait pas ide dinculquer ` des enfants des btises pareilles et que Shadoko, il fallait
e
a
e
le condamner. Il fut tr`s applaudi aussi. Les mathmatiques, cela les intressait, bien sr, mais
e
e
e
u
brler le professeur, ctait intressant aussi, faut dire. Il fut dcid ` lunanimit quon le
u
e
e
e e a
e
laisserait parler et quon le brlerait apr`s, ` la rcration.
u
e a
e e
Rptez avec moi : meu zo bu ga. . .ga bu zo meu.
e e
Et apr`s ! ricanait le Plombier.
e
Si je mets un Shadok en plus, videmment, je nai plus assez de mots pour les compter,
e
alors cest tr`s simple : on les jette dans une poubelle, et je dis que jai bu poubelle. Et pour
e
ne pas confondre avec le bu du dbut, je dis quil ny a pas de Shadok ` ct de la poubelle
e
a oe
et jcris bu ga. bu Shadok ` ct de la poubelle : bu bu. Un autre : bu zo. Encore
e
a oe
un autre : bu meu. On continue. zo poubelles et pas de Shadok ` ct : zo ga. . .meu
a oe
`
Fig. 1.16 : Regles de la division par 7
R`gle
e
7-1
7-2
7-3
7-4
7-5
7-6
7-7
1
2
1
2
1
2
1
2
1
2
1
2
1
2
Avant
0 0
0 1
0 0
0 2
0 0
0 3
0 0
0 4
0 1
0 0
0 1
0 1
0 1
0 2
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
2
1
2
1
2
1
2
1
2
1
2
1
2
Apr`s
e
0 0
0 1
0 0
0 2
0 0
0 4
0 1
0 0
0 1
0 2
0 1
0 3
0 0
1 0
0
3
1
1
0
2
1
0
0
1
0
4
0
0

26
poubelles et meu Shadoks ` ct : meu meu. Arriv l`, si je mets un Shadok en plus, il
a oe
e a
me faut une autre poubelle. Mais comme je nai plus de mots pour compter les poubelles,
je men dbarrasse en les jetant dans une grande poubelle. Jcris bu grande poubelle avec
e
e
pas de petite poubelle et pas de Shadok ` ct : bu ga ga, et on continue. . .bu ga bu,
a oe
bu ga zo. . .meu meu zo, meu meu meu. Quand on arrive l` et quon a trop de grandes
a
poubelles pour pouvoir les compter, eh bien, on les met dans une super-poubelle, on crit
e
bu ga ga ga, et on continue. . .(gure 1.18).
Fig. 1.17 : Les Shadoks : ga bu zo meu
1. Quels sont les entiers dcimaux reprsents en base Shadok par les expressions suie
e
e
vantes ?
(a) ga ga
(b) bu bu bu
(c) zo zo zo zo
(d) meu meu meu meu meu
2. Eectuer les calculs Shadok suivants.
(a) zo zo meu + bu ga meu
(b) meu ga meu bu meu ga
(c) zo meu meu bu ga meu
(d) zo zo zo meu bu ga zo
1.5.5
Solutions des exercices
Fig. 1.18 : Les 18 premiers nombres Shadok

0
1
2
3
4
5
:
:
:
:
:
:
ga
bu
zo
meu
bu ga
bu bu
6
7
8
9
10
11
:
:
:
:
:
:
bu
bu
zo
zo
zo
zo
zo
meu
ga
bu
zo
meu
12
13
14
15
16
17
:
:
:
:
:
:
meu ga
meu bu
meu zo
meu meu
bu ga ga
bu ga bu
TD 1.19 : QCM (1).

Les bonnes rponses sont extraites directement du texte de la section 1.1 :
e
1c, 2d, 3b, 4b, 5d, 6d, 7a, 8c
TD 1.20 : Puissance de calcul.
Lunit de puissance est donn ici en Mips ( million dinstructions par seconde ).
e
e
1. le premier micro-ordinateur de type PC : 101 Mips
2. une console de jeu actuelle : 104 Mips
3. un micro-ordinateur actuel : 104 Mips
4. Deeper-Blue : lordinateur qui a battu Kasparov aux checs en 1997 : 107 Mips
e

27
5. le plus puissant ordinateur actuel : 109 Mips

TD 1.21 : Stockage de donnes.
e
1. une page dun livre : 50 lignes de 80 caract`res = 4 ko
e
2. une encyclopdie en 20 volumes : 20 volumes de 1000 pages de 50 lignes de 80
e
caract`res = 80 Mo (sans images !)
e
3. une photo couleur : de 1Mo ` 100 Mo selon la qualit
a
e
4. une heure de vido : de 500 Mo ` 2 Go selon la qualit vido (DivX, MPEG-2. . .)
e
a
e
e
5. une minute de son : de 1 Mo (MP3) ` 10 Mo selon la qualit du son
a
e
6. une heure de son : de 60 Mo ` 600 Mo selon la qualit du son
a
e
Remarque 1.13 : Loi de Moore.

Gordon Earl Moore est le co-fondateur avec Robert Noyce
et Andrew Grove de la socit Intel en 1968 (fabriquant
ee
n 1 mondial de microprocesseurs). En 1965, il expliquait
que la complexit des semiconducteurs doublait tous les

e
dix-huit mois ` cot constant depuis 1959, date de leur
a u
invention. En 1975, il prcise sa premi`re loi en
e
e
armant que le nombre de transistors des microprocesseurs sur une puce de silicium double tous les deux ans
( deuxi`me loi ).
e
TD 1.22 : Dessins sur la plage : excution.

e
1. On trace un triangle rectangle dont lhypothnuse fait 5 pas de long (dapr`s le
e
e
thor`me de Pythagore : 52 = 32 + 42 ).
e e
2. On a donc march 3 + 4 + 5 = 12 pas.
e
TD 1.23 : Dessins sur la plage : conception.
Imaginons lalgorithme de trac suivant :
e
1. avance de 2 pas,
2. tourne ` gauche de 90 ,
a
3. avance de 3 pas,
a
5. avance de 4 pas,
a
7. avance de 5 pas,
a
9. avance de 6 pas.
validit : on doit au moins vrier que la gure obtenue ` toutes les caractristiques
e
e
a
e
recherches : spirale rectangulaire de 5 cts, le plus petit ct faisant 2 pas de long et
e
oe
oe
chaque ct fait un pas de plus que le prcdent (gure 1.19).
oe
e e
Fig. 1.19 : Spirales rectangulaires

28
robustesse : cet algorithme suppose quon a susamment de place pour tracer une
spirale (le dernier ct fait 6 pas de long) ; sil fonctionne correctement sur une plage, il
oe
ne fonctionnera certainement plus dans un placard.
rutilisabilit : il existe une innit de spirales rectangulaires qui ont les caractristiques
e
e
e
e
attendues ; il sut de penser ` changer lorientation initiale ou la longueur du pas par
a
exemple. On ne pourra donc pas utiliser lalgorithme tel quel dans toutes les congurations : il aurait fallu paramtrer langle de rotation et la longueur du pas.
e
complexit : on peut la caractriser par le nombre de pas : 2 + 3 + 4 + 5 + 6 = 20 pas.
e
e
ecacit : si la complexit se calcule en nombre de pas comme ci-dessus, on pourrait
e
e
imaginer par exemple que la frquence des pas soit plus grande ( frquence dhorloge )
e
e
ou que 5 personnes prennent en charge chacune un ct de la spirale pour gagner du
oe
temps ( syst`me multi-processeurs ).
e
TD 1.24 : Tracs de polygones rguliers.
e
e
1. Pentagone rgulier de 10 pas de ct.
e
oe
(b) tourne ` gauche de (360/5) ,
a
(c) avance de 10 pas,
(d) tourne ` gauche de
a
On remarque quon a eectu 5 fois de

e
suite les 2 instructions suivantes :
(360/5) ,
(e) avance de 10 pas,

(f) tourne ` gauche de (360/5) ,
a
(b) tourne ` gauche de (360/5) .

a
Pour simplier, on crira plutt :
e
o
Rp`te 5 fois de suite les 2 instructions
e e
(g) avance de 10 pas,
(h) tourne ` gauche de (360/5) ,

a
(b) tourne ` gauche de (360/5) .

a
(i) avance de 10 pas,

(j) tourne ` gauche de (360/5) .
a
2. Hexagone rgulier de 10 pas de ct.
e
oe
e e
a
3. Octogone rgulier de 10 pas de ct.
e
oe
e e
Cest ce que nous ferons dans les exemples

suivants.

29

a
4. Polygone rgulier de n cts de 10 pas chacun.
e
oe
Rp`te n fois de suite les 2 instructions
e e
(b) tourne ` gauche de (360/n) ,
a
TD 1.25 : Multiplication ` la russe .
a
1.
2.
multiplicande
M 2
96
192
384
768
1536
3072
6144
multiplicateur
m2
64
32
16
8
4
2
1
reste
m mod 2
0
0
0
0
0
0
1
64 96 =
multiplicande
M 2
239
478
956
1912
3824
7648
multiplicateur
m2
45
22
11
5
2
1
reste
m mod 2
1
0
1
1
0
1
45 239 =
somme partielle
(0 96) + 0
(0 192) + 0
(1 384) + 0
(0 768) + 0
(0 1536) + 0
(0 3072) + 0
(1 6144) + 0
6144
somme partielle
(1 239) + 0
(0 478) + 239
(1 956) + 239
(1 1912) + 1195
(0 3824) + 3107
(1 7648) + 3107
10755
TD 1.26 : Multiplication arabe : 63247 124 = 7842628.

30
7
8
8
4
6
3
2
2
8
6
4
2
2 4
1 2
6
2
Remarque 1.14 :
Boulier chinois : division par 3.
1. san-yi sanshi-yi : trois-un ? trente et un !

(on pose 3 ` la place du 1, et on ajoute 1 ` droite)
a
a
2. san-er liushi-er : trois-deux ? soixante deux !
(on pose 6 ` la place du 2, et on ajoute 2 ` droite)
a
a
Remarque 1.15 : Un entier positif en base b est

reprsent par une suite de chires (rn rn1 . . . r1 r0 )b o`
e
e
u
les ri sont des chires de la base b (0 ri < b). Ce
nombre a pour valeur :
rn bn + rn1 bn1 + . . . + r1 b1 + r0 b0 =
i=n
X
ri bi
i=0
Un nombre fractionnaire (nombre avec des chires apr`s

e
la virgule : (rn rn1 . . . r1 r0 .r1 r2 . . .)b ) est dni sur un
e
sous-ensemble born, incomplet et ni des rationnels. Un
e
tel nombre a pour valeur :
rn bn + rn1 bn1 + . . . + r0 b0 + r1 b1 + r2 b2 + . . .
En pratique, le nombre de chires apr`s la virgule est
e
limit par la taille physique en machine.
e
(rn rn1 . . . r1 r0 .r1 r2 . . . rm )b =
i=n
X
i=m
ri bi
TD 1.27 : Division chinoise : 1234 7 (1234 = 176 7 + 2).
1
0 0 0 0 7-1 1
0 1 0 0 7-5 1
2
1 2 3 4
2
1 0 3 4
2
3. feng san jin yi-shi : trois-trois ? dizaine monte !

e
(on pose 0 ` la place du 3, et on ajoute 1 ` gauche)
a
a
Eectuer la division 2271 3 avec le boulier chinois.
8
rsultat
1
2
0
1
1
2
0
4
0 7-4 1
4
2
0
1
1
2
1
0
1 7-7 1
4
2
0
1
1
2
0
4
0
1
1
2
1
1
0
4
0
2
TD 1.28 : Calcul Shadok.

Le syst`me Shadok est un syst`me de numration en base 4 :
e
e
e
ga = 0, bu = 1, zo = 2 et meu = 3.
1. (a) ga ga = (00)4 = 0
(b) bu bu bu = (111)4 = 1 42 + 1 41 + 1 40 = 16 + 4 + 1 = 21
(c) zo zo zo zo = (2222)4 = 2 43 + 2 42 + 2 41 + 2 40 = 128 + 32 + 8 + 2 = 170
(d) meu meu meu meu meu = (33333)4 = 3 44 + 3 43 + 3 42 + 3 41 + 3 40 =
768 + 192 + 48 + 12 + 3 = 1023
2. (a) zo zo meu + bu ga meu = (223)4 + (103)4 = (332)4 = 43 + 19 = 62
(b) meu ga meu bu meu ga = (303)4 (130)4 = (113)4 = 51 28 = 23
(c) zo meu meu bu ga meu = (233)4 (103)4 = (31331)4 = 47 19 = 893
(d) zo zo zo meu bu ga zo = (2223)4 (102)4 = (21)4 = 171 18 = 9
1.6. ANNEXES
1.6
1.6.1
31
Annexes
Lettre de Jacques Perret
Au printemps de 1955, IBM France sapprtait ` construire dans ses ateliers de Corbeile
a
Essonnes (consacrs jusque-l` au montage des machines mcanographiques tabulatrices,
e
a
e
trieuses, . . . de technologie lectromcanique) les premi`res machines lectroniques destines
e
e
e
e
e
au traitement de linformation. Aux Etats-Unis ces nouvelles machines taient dsignes sous
e
e
e
le vocable Electronic Data Processing System. Le mot computer tait plutt rserv aux
e
o e
e
machines scientiques et se traduisait aisment en calculateur ou calculatrice . Sollicit
e
e
par la direction de lusine de Corbeil-Essonnes, Franois Girard, alors responsable du service
c
promotion gnrale publicit, dcida de consulter un de ses anciens ma
e e
e e
tres, Jacques Perret,
professeur de philologie latine ` la Sorbonne. A cet eet il crit une lettre ` la signature de C.
a
e
a
de Waldner, prsident dIBM France. Il dcrit sommairement la nature et les fonctions des noue
e
velles machines. Il accompagne sa lettre de brochures illustrant les machines mcanographiques.
e
Le 16 avril, le professeur Perret lui rpond. Lordinateur IBM 650 peut commencer sa carri`re.
e
e
Protg pendant quelques mois par IBM France, le mot fut rapidement adopt par un public
e e
e
de spcialistes, de chefs dentreprises et par ladministration. IBM dcida de le laisser dans le
e
e
`
domaine public (dapr`s le site de la 10eme semaine de la langue franaise et de la francophonie
e
c
www.semainelf.culture.fr/site2005/dixmots).
Le 16 IV 1955
Cher Monsieur,
Que diriez-vous d ordinateur ? Cest un mot correctement form, qui se trouve mme
e
e
dans le Littr comme adjectif dsignant Dieu qui met de lordre dans le monde. Un mot de
e
e
ce genre a lavantage de donner aisment un verbe ordiner , un nom daction ordinae
tion . Linconvnient est que ordination dsigne une crmonie religieuse ; mais les deux
e
e
e e
champs de signication (religion et comptabilit) sont si loigns et la crmonie dordination
e
e
e
e e
connue, je crois, de si peu de personnes que linconvnient est peut-tre mineur. Dailleurs votre
e
e
machine serait ordinateur (et non ordination) et ce mot est tout ` fait sorti de lusage
a
thologique. Systmateur serait un nologisme, mais qui ne me para pas oensant ; il pere
e
e
t
met systmatis ; - mais syst`me ne me semble gu`re utilisable - combinateur a
e
e
e
e
linconvnient du sens pjoratif de combine ; combiner est usuel donc peu capable de
e
e
devenir technique ; combination ne me para gu`re viable ` cause de la proximit de comt e
a
e
binaison . Mais les Allemands ont bien leurs combinats (sorte de trusts, je crois), si bien
Fig. 1.20 : Le premier ordinateur (1946)

ENIAC (Electronic Numerical Integrator Analyser
and Computer).
Fig. 1.21 : Premiers micro-ordinateurs
Apple II (1977)
IBM PC (1981)
ZX 81 (1981)
Macintosh (1984)
32
Fig. 1.22 : Du 8086 (1978) au Core 2 (2006)
8086
Pentium 4
80486
Core Duo
Fig. 1.23 : Micro-ordinateurs recents
PDA
iPhone
Tablette
Wii

que le mot aurait peut-tre des possibilits autres que celles quvoque combine .
e
e
e
Congesteur , digesteur voquent trop congestion et digestion . Synthtie
e
seur ne me para pas un mot assez neuf pour designer un objet spcique, dtermin comme
t
e
e
e
votre machine. En relisant les brochures que vous mavez donnes, je vois que plusieurs de vos
e
appareils sont dsigns par des noms dagent fminins (trieuse, tabulatrice). Ordinatrice
e
e
e
serait parfaitement possible et aurait mme lavantage de sparer plus encore votre machine du
e
e
vocabulaire de la thologie. Il y a possibilit aussi dajouter ` un nom dagent un complment :
e
e
a
e
ordinatrice dlments complexes ou un lment de composition, par ex. : slecto-systee
ee
e
e
mateur . - Slecto- ordinateur a linconvnient de 2 o en hiatus, comme lectroe
e
e
ordinatrice . Il me semble que je pencherais pour ordinatrice lectronique . Je souhaite que
e
ces suggestions stimulent, orientent vos propres facults dinvention. Nhsitez pas ` me donner
e
e
a
un coup de tlphone si vous avez une ide qui vous paraisse requrir lavis dun philologue.
ee
e
e
Vtre.
o
J. Perret
1.6. ANNEXES
1.6.2
33
Exemple de questionnaire dvaluation

e
Proposition
1 2
Vos connaissances antrieures taient susantes pour suivre ce 2 2
e
e
cours
Les objectifs du cours ont t clairement dnis
ee
e
2 2
Vous tes satisfait des supports de cours fournis
e
2 2
2 2
Vous tes satisfait de lquilibre cours/TD/TP
e
e
Vous tes satisfait de la prsentation de ce cours (clart dexpres- 2 2
e
e
e
sion. . .)
Si vous avez plusieurs professeurs, la cohrence de lenseignement 2 2
e
vous a sembl assure
e
e
Le rythme de travail vous a permis de suivre et de comprendre
2 2
Le temps allou ` cette mati`re vous a sembl satisfaisant
ea
e
e
2 2
2 2
Cette mati`re a ncessit beaucoup de travail personnel
e
e
e
Vous avez eu limpression de progresser
2 2
Les contrles sont adapts ` lobjectif et au niveau du cours
o
e a
2 2
Vous tes satisfait du mode dvaluation
e
e
2 2
Apr`s les contrles, les enseignants fournissent des commentaires 2 2
e
o
qui aident ` mieux maitriser la mati`re
a
e
Vous tes satisfait des conditions de travail (salles de cours, 2 2
e
matriel utilis. . .)
e
e
Respect du programme pdagogique
e
2 2
1 :Tr`s satisfait , 2 :Satisfait , 3 :Peu satisfait , 4 :Pas satisfait ; :Ne me
e
3
2
4
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2 2
2
concerne pas

34
1.6.3
Exemple de planning
Les enseignements dInformatique S1 stalent sur 14 semaines.

e
Semaine
1
2
3
4
5
Cours-TD
introduction gnrale
e e
instructions de base
CAF1 : calculs boolens

e
DS1 : instructions de base
7
8
procdures et fonctions
e
9
10
CAF2 : codage des nombres

e
11
12
e
13
DS2 : procdures et fonctions

e
structures linaires
e
14
TD
environnement de programmation
CTD1 : aectation et tests
CTD2 : boucles simples

CTD3 : boucles imbriques

e
CTD4 : spcication de fonctions

e
e
CTD5 : implmentation de fonctions

e
e
CTD6 : appel de fonctions

e
CTD7 : manipulation de listes

structures linaires
e
CAF : contrle dautoformation (crit individuel, 30, sans document)
o
e
CTD : contrle de travaux dirigs (sur machine par binme, 10, sans document)
o
e
o
DS : devoir surveill (crit individuel, 80, sans document)
e e
1.6. ANNEXES
1.6.4
35
Informatique ` lENIB
a
ENIB : www.enib.fr
Enseignements de premier cycle

Les 4 semestres du premier cycle (S1 ` S4) sont communs ` tous les l`ves de lENIB. Les
a
a
ee
enseignements dinformatique sont prciss dans le tableau ci-dessous.
e e
Semestre
S1
S2
S3
S3
S4
Th`me
e
Algorithmique
Mthode de dveloppement
e
e
Programmation procdurale
e
Programmation par objets
Programmation pour lembarqu
e
Horaires
42 h
42 h
42 h
42 h
42 h
Enseignements du cycle ingnieur

e
Les 2 premiers semestres du cycle ingnieur (S5 et S6) sont communs ` tous les l`ves de
e
a
ee
lENIB.
Semestre
S5
S6
S6
S6
Th`me
e
Mod`les pour lingnierie des syst`mes
e
e
e
Bases de donnes
e
Horaires
42 h
42 h
42 h
21 h
`
Au cours du 3eme semestre du cycle ingnieur (S7), les l`ves choisissent une option parmi
e
ee
trois : lectronique, informatique ou mcatronique. Les modules de loption informatique sont
e
e
`
lists dans le tableau ci-dessous. Le 4eme semestre (S8) est consacr ` un Projet Professionnalisant
e
ea
en Equipe (PPE) ou ` un stage en entreprise.
a

36
Semestre
S7
S7
S7
S7
S7
S7
S7
S7
Th`me
e
Syst`mes embarqus 1
e
e
Syst`mes embarqus 2
e
e
Rseaux
e
Administration Syst`mes et Rseaux
e
e
Gnie Logiciel
e
Syst`mes dInformation
e
Interfaces Homme-Machine
Applications Rparties
e
Horaires
42 h
42 h
42 h
42 h
42 h
42 h
42 h
42 h
`
Au cours du 5eme semestre du cycle ingnieur (S9), les tudiants doivent suivre 9 modules
e
e
scientiques, les modules ` caract`re informatique sont donns dans le tableau ci-dessous. Le
a
e
e
dernier semestre (S10) est consacr au stage en entreprise.
e
Semestre
S9
S9
S9
S9
S9
Th`me
e
Syst`mes distribus
e
e
Contrle adaptatif
o
Styles de programmation
Intelligence articielle et Simulation
Ralit Virtuelle
e e
Horaires
42 h
42 h
42 h
42 h
42 h
Recherches en informatique
LISyC : www.lisyc.univ-brest.fr
LENIB accueille trois laboratoires de recherche correspondant aux trois options : lectronique,
e
informatique et mcatronique.
e
Le laboratoire de recherche en informatique de lENIB est le LISyC (Laboratoire dInformatique des Syst`mes Complexes). Le LISyC est ` Brest une Equipe dAccueil (EA 3883) commune
e
a
a
` lUniversit de Bretagne Occidentale (UBO), ` lEcole Nationale dIngnieurs de Brest (ENIB)
e
a
e
et ` lEcole Nationale Suprieure des Ingnieurs des Etudes des Techniques dArmement (ENa
e
e
SIETA).
Le LISyC a fait sienne lide selon laquelle comprendre et ma
e
triser les comportements des
syst`mes complexes, naturels ou articiels, constituent pour les scientiques le d majeur du
e
e
eme si`cle. Il compte actuellement 50 enseignants-chercheurs permanents et 25 doctorants
`
21
e
1.6. ANNEXES
37
regroups en 4 quipes STIC et 1 quipe SHS qui explorent de mani`re complmentaire cette
e
e
e
e
e
problmatique :
e
AReVi
in virtuo
IdM
SARA
SuSy
:
:
:
:
:
Ateliers de Ralit Virtuelle

e e
in virtuo
Ingnierie des Mod`les
e
e
Simulation, Apprentissages, Reprsentations, Action
e
Sret des Syst`mes
u e
e
Les quipes AReVi, in virtuo et SARA sont localises au CERV : le Centre Europen de
e
e
e
Ralit Virtuelle, tablissement de lENIB ouvert en juin 2004.
e e
e
CERV : www.cerv.fr
38

Chapitre 2
Instructions de base
Sommaire
2.1
2.2
Informatique
S1
2.3
a
2.4
Jacques TISSEAU
2.5

o
enib c 2009
2.6
tisseau@enib.fr
enib c 2009
Algorithmique
39
1/30
Introduction . . . . . . . . . . . . .
2.1.1 Jeu dinstructions . . . . . .
2.1.2 Instructions de base . . . .
Aectation . . . . . . . . . . . . . .
2.2.1 Variables . . . . . . . . . . .
2.2.2 Attribuer une valeur . . . .
2.2.3 Squences daectations . .
e
Tests . . . . . . . . . . . . . . . . . .
2.3.1 Tests simples . . . . . . . . .
2.3.2 Alternatives simples . . . .
2.3.3 Alternatives multiples . . .
Boucles . . . . . . . . . . . . . . . .
2.4.1 Itration conditionnelle . .
e
2.4.2 Parcours de squences . . .
e
2.4.3 Imbrications de boucles . .
2.4.4 Excutions de boucles . . .
e
Exercices complmentaires . . . . .
e
2.5.1 Conna
tre . . . . . . . . . . .
2.5.2 Comprendre . . . . . . . . .
2.5.3 Appliquer . . . . . . . . . . .
2.5.4 Analyser . . . . . . . . . . .
2.5.5 Solutions des exercices . . .
Annexes . . . . . . . . . . . . . . . .
2.6.1 Instructions Logo . . . . . .
2.6.2 Instructions Python . . . .
2.6.3 Construction dune boucle
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
40
40
41
42
42
43
45
46
47
48
49
51
52
56
59
61
63
63
66
72
74
76
91
91
92
95
40
CHAPITRE 2. INSTRUCTIONS DE BASE
2.1
Introduction
e
e
a
rsoudre une srie de probl`mes quivalents. Ainsi quand on dnit un algorithme, celui-ci ne
e
e
e
e
e
doit contenir que des instructions comprhensibles par celui qui devra lexcuter. Dans ce cours,
e
e
nous devrons donc apprendre ` dnir des algorithmes pour quils soient comprhensibles et
a e
e
donc excutables par un ordinateur.
e
2.1.1
Remarque 2.1 : On distingue classiquement 2 grands
types darchitectures de micro-processeurs :
les architectures risc (Reduced Instruction Set Computer) prconisent un petit nombre dinstructions
e
lmentaires dans un format xe ;
ee
les architectures cisc (Complex Instruction Set Computer) sont bases sur des jeux dinstructions tr`s
e
e
riches de taille variable orant des instructions composes de plus haut niveau dabstraction.
e
Chaque architecture poss`de ses avantages et ses ine
convnients : pour le risc la complexit est reporte au
e
e
e
niveau du compilateur, pour le cisc le dcodage est plus
e
pnalisant. En fait les machines cisc se sont orientes
e
e
vers une architecture risc o` les instructions cisc sont
u
traduites en instructions risc traites par le coeur du proe
cesseur.
Jeu dinstructions
Chaque microprocesseur a son jeu dinstructions de base dont le nombre varie typiquement
de quelques dizaines ` quelques centaines selon le type darchitecture du processeur. On peut
a
classer ces instructions de base en 5 grands groupes : les oprations arithmtiques (+, -, *, /. . .),
e
e
les oprations logiques (not, and, or. . .), les instructions de transferts de donnes (load, store,
e
e
move. . .), les instructions de contrle du ux dinstructions (branchements impratifs et condio
e
tionnels, boucles, appels de procdure. . .), et les instructions dentre-sortie (read, write. . .).
e
e
Le traitement des ces instructions par le microprocesseur passe ensuite par 5 tapes :
e
1. fetch : chargement depuis la mmoire de la prochaine instruction ` excuter,
e
a e
2. decode : dcodage de linstruction,
e
3. load operand : chargement des donnes ncessaires ` linstruction,
e
e
a
4. execute : excution de linstruction,
e
Remarque 2.2 : Le coeur du microprocesseur est

rgul par un quartz qui oscille avec une frquence exe e
e
prime en Hz. Le temps de cycle est linverse de la
e
frquence. Ainsi pour une frquence de 100 MHz, on a
e
e
un temps de cycle de 10 ns. Lexcution dune instruce
tion ncessite plusieurs temps de cycle, cest ce que lon
e
appelle le cpi (Cycles per Instruction).
5. result write back : mise ` jour du rsultat dans un registre ou en mmoire.

a
e
e
Le langage machine est le langage compris par le microprocesseur. Ce langage est dicile `
a
ma
triser puisque chaque instruction est code par une squence donne de bits. An de faciliter
e
e
e
la tche du programmeur, on a dabord cr le langage assembleur qui utilise des mnmoniques
a
ee
e
pour le codage des instructions puis les langages de plus haut niveau dexpressivit (fortran, C,
e
Java, Python. . .). Le tableau ci-dessous compare les codes quivalents pour dcrire laddition
e
e
de 2 entiers dans dirents langages informatiques : le langage machine, le langage assembleur,
e
le langage Pascal et le langage Python. On constate sur cet exemple une volution progressive
e
2.1. INTRODUCTION
41
du pouvoir dexpressivit des langages, du langage machine aux langages de haut niveau.
e
machine
2.1.2
assembleur
Pascal
Python
A1
8B
01
A3
MOV
MOV
ADD
MOV
var a,b,c : integer ;

c := a + b ;
c = a + b
00 01
1E 02 01
D8
04 01
AX,[100h]
BX,[102h]
AX,BX
[104h],AX
Instructions de base
Dans ce cours, nous nous intresserons aux instructions disponibles dans un langage de
e
haut niveau tel que Python. Les principales instructions (statements) concerneront laectation
(assignment), les tests (conditional statements) et les boucles (loops). Le tableau ci-dessous donne
la syntaxe Python des instructions de base qui seront utilises dans ce chapitre (dapr`s [10]).
e
e
Une liste plus dtaille des principales instructions en Python est propose en annexe 2.6.2
e
e
e
page 92.
Statement
pass
print([s1] [, s2 ]*)
a = b
if condition :
suite
[elif condition : suite]*
[else :
suite]
while condition :
suite
for element in sequence :
suite
Result
Null statement
Writes to sys.stdout. Puts spaces between arguments si. Puts newline at end unless arguments end
with end= (ie : end= ). print is not required when
running interactively, simply typing an expression will
print its value, unless the value is None.
Basic assignment - assign object b to label a
Usual if/else if/else statement.
Usual while statement.

Iterates over sequence, assigning each element to
element. Use built-in range function to iterate a number of times.
Python : www.python.org
Remarque 2.3 : Langlais est la langue couramment

utilise en informatique. Il est absolument essentiel de
e
lire langlais technique sans probl`me. Vous devez tre
e
e
capable de traduire le tableau ci-contre extrait sans traduction dune rfrence en anglais [10].
ee
42
2.2
2.2.1
TD 2.1 : Unite de pression

Le torr (torr) ou millim`tre de mercure (mmHg) est
e
une unit de mesure de la pression qui tire son nom du
e
physicien et mathmaticien italien Evangelista Torricelli
e
(1608-1647). Il est dni comme la pression exerce ` 0 C
e
e a
par une colonne de 1 millim`tre de mercure (mmHg). Il
e
a plus tard t indexe sur la pression atmosphrique :
ee
e
e
1 atmosph`re normale correspond ` 760 mmHg et a 101
e
a
325 Pa.
Ecrire une instruction qui permette de passer directement
des torrs au pascals (Pa).
Fig. 2.1 : Definition de lacademie (4)
DENOTER v. tr. XIVe si`cle. Emprunt du lae

e
tin denotare, dsigner, faire conna
e
tre . 1. Indiquer comme caractristique, signier, rvler. 2.
e
e e
LOGIQUE. Dsigner la totalit des objets dont les
e
e
caract`res sont xs par un concept.
e
e
Remarque 2.4 : Une variable peut tre vue comme

e
une case en mmoire vive, que le programme va reprer
e
e
par une tiquette (une adresse ou un nom). Pour avoir
e
acc`s au contenu de la case (la valeur de la variable), il
e
sut de la dsigner par son tiquette : cest-`-dire soit
e
e
a
par son adresse en mmoire, soit par son nom.
e
Remarque 2.5 : En mathmatiques, une variable
e
est gnralement une inconnue, qui recouvre un nombre
e e
non prcis de valeurs. En informatique, une variable
e e
poss`de ` un moment donn une valeur et une seule.
e a
e
Aectation
Variables
Exemple 2.1 : La temperature Fahrenheit

Le degr Fahrenheit ( F ) est une unit de mesure de la temprature, qui doit son nom au phye
e
e
sicien allemand Daniel Gabriel Fahrenheit (1686-1736), qui la proposa en 1724. Dans lchelle
e
de temprature de Fahrenheit, le point de solidication de leau est de 32 degrs, et son point
e
e
dbullition de 212 degrs. Ainsi par exemple, 70 F correspondent approximativement ` 21 C.
e
e
a
Pour eectuer la conversion Fahrenheit Celcius, nous commenons par donner un nom ` la
c
a
temprature Fahrenheit, par exemple tF , ainsi qu` la temprature Celcius, par exemple tC . Puis
e
a
e
5
nous pouvons exprimer la relation gnrale qui lie tC ` tF : tC = (tF 32) et appliquer cette
e e
a
9
5
relation dans un cas particulier, par exemple tF = 70 : tC = (70 32) 21.
TD2.1
9
En informatique, lessentiel du travail eectu par un programme dordinateur consiste `
e
a
manipuler des donnes. Ces donnes peuvent tre tr`s diverses (par exemple des tempratures)
e
e
e
e
e
et pour accder ` ces donnes, il est pratique de les nommer plutt que de conna explicitement
e
a
e
o
tre
leur adresse en mmoire.
e
Une donne appara ainsi sous un nom de variable (par exemple tC ou tF) : on dit que la
e
t
ee
e
variable dnote une valeur (gure 2.1). Pour la machine, il sagit dune rfrence dsignant une
e
adresse mmoire, cest-`-dire un emplacement prcis dans la mmoire vive o` est stocke une
e
a
e
e
u
e
valeur bien dtermine qui est la donne proprement dite.
e
e
e
Dnition 2.1 : variable
e
Une variable est un objet informatique qui associe un nom ` une valeur qui peut ventuellement
a
e
varier au cours du temps.
Les noms de variables sont des identicateurs arbitraires, de prfrence assez courts mais aussi
ee
explicites que possible, de mani`re ` exprimer clairement ce que la variable est cense rfrencer
e a
e ee
(la smantique de la donne rfrence par la variable). Les noms des variables doivent en outre
e
e ee
e
obir ` quelques r`gles simples :
e a
e
Un nom de variable est une squence de lettres (a. . .z , A. . .Z) et de chires (0. . .9), qui
e
doit toujours commencer par une lettre.
2.2. AFFECTATION
43
Seules les lettres ordinaires sont autorises. Les lettres accentues, les cdilles, les espaces,
e
e
e
les caract`res spciaux tels que $, #, @, etc. sont interdits, ` lexception du caract`re
e
e
a
e
(soulign).
e
La casse est signicative : les caract`res majuscules et minuscules sont distingus.
e
e
Ainsi, python, Python, PYTHON sont des variables direntes.
e
Par convention, on crira lessentiel des noms de variable en caract`res minuscules (y come
e
pris la premi`re lettre). On nutilisera les majuscules qu` lintrieur mme du nom pour en
e
a
e
e
augmenter ventuellement la lisibilit, comme dans programmePython ou angleRotation.
e
e
Une variable dont la valeur associe ne varie pas au cours du programme (on parle alors
e
de constante) pourra tre crite enti`rement en majuscule, par exemple PI ( = 3.14).
e
e
e
Le langage lui-mme peut se rserver quelques noms comme cest le cas pour Python
e
e
(gure 3.5). Ces mots rservs ne peuvent donc pas tre utiliss comme noms de variable.
e
e
e
e
2.2.2
Fig. 2.2 : Mots reserves en Python

and
assert
break
class
continue
def
del
elif
else
except
exec
finally
for
from
global
if
import
in
is
lambda
not
or
pass
print
raise
return
try
while
with
yield
Attribuer une valeur
Une fois nomme, il est souvent ncessaire de modier la valeur de la donne rfrence par
e
e
e ee
e
une variable. Cest le rle de linstruction daectation.
o
Dnition 2.2 : affectation
e
Laectation est lopration qui consiste ` attribuer une valeur ` une variable.
e
a
a
Linstruction daectation est note = en Python : variable = valeur . Le nom de la

e
variable ` modier est plac dans le membre de gauche du signe =, la valeur quon veut lui
a
e
attribuer dans le membre de droite. Le membre de droite de laectation est dabord valu
e
e
sans tre modi puis la valeur obtenue est aecte ` la variable dont le nom est donn dans le
e
e
e a
e
membre de gauche de laectation ; ainsi, cette opration ne modie que le membre de gauche
e
de laectation. Le membre de droite peut tre une constante ou une expression valuable.
e
e
variable = constante : La constante peut tre dun type quelconque (gure 2.3) : entier,
e
rel, boolen, cha de caract`res, tableau, matrice, dictionnaire. . . comme le sugg`rent
e
e
ne
e
e
les exemples suivants :
Fig. 2.3 : Types de base en Python

type
boolens
e
entiers
rels
e
cha
nes
n-uplets
listes
dictionnaires
nom
bool
int
float
str
tuple
list
dict
exemples
False, True
3, -7
3.14, 7.43e-3
salut, "leau"
1,2,3
[1,2,3]
{a :4, r :8}
44

booleen = False
entier = 3
reel = 0.0
chaine = "salut"
tableau = [5,2,9,3]
matrice = [[1,2],[6,7]]
nUplet = 4,5,6
dictionnaire = {}
TD 2.2 : Suite arithmetique (1)

P
Ecrire une instruction qui calcule la somme s = n uk
0
des n premiers termes dune suite arithmtique uk = a +
e
r k.
INCREMENT n. m. XVe si`cle, encrement. Eme

prunt du latin incrementum, accroissement . INe
FORM. Quantit xe dont on augmente la valeur
e
dune variable ` chaque phase de lexcution du proa
e
gramme.
DECREMENT n. m. XIXe si`cle. Emprunt de

e
e
langlais decrement, du latin decrementum, amoindrissement, diminPrincipales aectations en Pythonution . MATH. INFORM. Quantit xe dont
e
une grandeur diminue ` chaque cycle.
a
variable = expression : Lexpression peut tre nimporte quelle expression valuable telle
e
e
quune opration logique (x = True or False and not True), une opration arithmtie
e
e
que (x = 3 + 2*9 - 6*7), un appel de fonction (y = sin(x)) ou toute autre combinaison
valuable (x = (x != y) and (z + t >= y) or (sin(x) < 0)).
e
TD2.2
reste =
somme =
delta =
surface
Remarque 2.6 : Avec lexemple de lincrmentation

e
(i = i + 1), on constate que laectation est une
opration typiquement informatique qui se distingue de
e
lgalit mathmatique. En eet, en mathmatique une
e
e
e
e
expression du type i = i+1 se rduit en 0 = 1 ! Alors
e
quen informatique, lexpression i = i+1 conduit ` ajoua
ter 1 ` la valeur de i (valuation de lexpression i+1),
a
e
puis ` donner cette nouvelle valeur ` i (aectation).
a
a
Fig. 2.5 : Principales affectations en Python

a
a
a
a
a
a
a
= b
+= b
-= b
*= b
/= b
%= b
**= b
a
a
a
a
a
a
=
=
=
=
=
=
a
a
a
a
a
a
+ b
- b
* b
/ b
% b
** b
autreBooleen = True
autreEntier = -329
autreReel = -5.4687e-2
autreChaine = bonjour, comment a va ?
c
autreTableau = [a,[6,3.14],[x,y,[z,t]]]
autreMatrice = [[1,2],[3,4],[5,6],[7,8]]
autreNUplet = "e",True,6.7,3,"z"
autreDictionnaire = {"a":7, "r":-8}
a%b
n*(n+1)/2
b*b - 4*a*c
= pi*r**2
quotient = a/b
sommeGeometrique = s = a*(b**(n+1) - 1)/(b-1)
racine = (-b + sqrt(delta))/(2*a)
volume = surface * hauteur
Lexpression du membre de droite peut faire intervenir la variable du membre de gauche

comme dans i = i + 1. Dans cet exemple, on value dabord le membre de droite (i +
e
1) puis on attribue la valeur obtenue au membre de gauche (i) ; ainsi, ` la n de cette
a
aectation, la valeur de i a t augmente de 1 : on dit que i a t incrment de 1 (gure
ee
e
ee
e
e
2.4) et on parle dincrmentation de la variable i (remarque 2.6). Python propose un
e
oprateur dincrmentation (+=) et dautres oprateurs daectation qui peuvent toujours
e
e
e
se ramener ` lutilisation de loprateur =, loprateur daectation de base (gure 2.5).
a
e
e
Laectation a ainsi pour eet de raliser plusieurs oprations dans la mmoire de lordinae
e
e
teur :
crer et mmoriser un nom de variable,

e
e
lui attribuer un type bien dtermin,
e
e
crer et mmoriser une valeur particuli`re,
e
e
e
tablir un lien (par un syst`me interne de pointeurs) entre le nom de la variable et leme
e
placement mmoire de la valeur correspondante.
e
2.2. AFFECTATION
2.2.3
45
Squences daectations
e
Exemple 2.2 : Permutation de 2 nombres

Un apprenti informaticien a qui on demandait dchanger (swap) les valeurs de 2 variables x et
e
y proposa la suite dinstructions suivante :
x = y
y = x
et eut la dsagrable surprise de constater que les valeurs des variables ntaient pas permutes
e
e
e
e
apr`s cette squence daectations.
e
e
En eet, pour xer les ides supposons quinitialement x = 10 et y = 20. Laectation x = y
e
conduit ` valuer y puis ` attribuer la valeur de y (20) ` x : x vaut maintenant 20. La deuxi`me
ae
a
a
e
aectation (y = x) commence par valuer x puis ` attribuer la valeur de x (20 !) ` y. Apr`s
e
a
a
e
ces 2 aectations, x et y sont donc identiques et non permutes ! Pour eectuer la permutation,
e
lapprenti informaticien aurait pu utiliser une variable temporaire (que nous nommerons tmp)
et excuter la squence dinstructions suivante :
e
e
La premi`re aectation (tmp = x) permet de stocker la valeur initiale de x (10), la deuxi`me
e
e
(x = y) attribue ` x la valeur de y (20) et la troisi`me (y = tmp) attribue ` y la valeur de
a
e
a
tmp, cest-`-dire la valeur initiale de x (10). Ainsi, les valeurs nales de x et y (20 et 10) sont
a
bien permutes par rapport aux valeurs initiales (10 et 20).
e
TD2.3
tmp = x
x = y
y = tmp
Exemple 2.3 : Un calcul de pgcd (1)

Le plus grand commun diviseur de 2 entiers a et b peut se calculer en appliquant la relation de
rcurrence pgcd(a, b) = pgcd(b, a%b) si b = 0 jusqu` ce que le reste (a%b) soit nul (pgcd(d, 0) =
e
a
d si d = 0).
Ainsi, pour calculer le pgcd de a = 12 et de b = 18, on applique 3 fois de suite cette relation :
pgcd(a, b) = pgcd(b, a%b) pgcd(12, 18) = pgcd(18, 12) = pgcd(12, 6) = pgcd(6, 0) = 6. Ce qui
peut se traduire en Python par la squence daectations suivante :
e
a
b
r
a
b
r
=
=
=
=
=
=
12
18
a%b
b
r
a%b
#
#
#
#
#
#
a = 12
b = 18
r = 12
a = 18
b = 12
r=6
a
b
r
a
b
=
=
=
=
=
b
r
a%b
b
r
#
#
#
#
#
a = 12
b=6
r=0
a=6
b=0
A la n de la squence, on a a = 6 et b = 0 : a est le pgcd recherch.

e
e
TD2.4
Remarque 2.7 : Laectation nest pas une opration

e
commutative (symtrique) : a = b = b = a. En eet,
e
avec linstruction a = b on modie la valeur de a et pas
celle de b tandis quavec linstruction b = a, on modie
b mais pas a.
Remarque 2.8 : En Python, les n-uplets permettent

dcrire plus simplement la permutation de variables :
e
x, y = y, x
TD 2.3 : Permutation circulaire (1)
Eectuer une permutation circulaire droite entre les valeurs de 4 entiers x, y, z et t.
TD 2.4 : Sequence daffectations (1)

Quelles sont les valeurs des variables a, b, q et r apr`s la
e
squence daectations suivante ?
e
a = 19
b = 6
q = 0
r = a
r = r - b
q = q + 1
r = r - b
q = q + 1
r = r - b
q = q + 1
46
Les 2 exemples 2.2 et 2.3 prcdents illustrent la possibilit de raliser des calculs plus ou
e e
e
e
moins compliqus ` laide dune squence daectations bien choisies. Mais ce sont les tests et
e a
e
les boucles qui nous permettront daborder des algorithmes rutilisables, et plus robustes, en
e
amliorant lexpressivit du programmeur.
e
e
2.3
Fig. 2.6 : Flux dinstructions
instruction1
instruction2
instruction3

ALTERNATIVE n. f. XVe si`cle, comme terme
e
de droit ecclsiastique ; XVIIe si`cle, au sens moe
e
derne. Forme fminine substantive dalternatif.
e
e
Choix ncessaire entre deux propositions, deux ate
titudes dont lune exclut lautre.
Tests
Sauf mention explicite, les instructions dun algorithme sexcutent les unes apr`s les autres,
e
e
dans lordre o` elles ont t crites. Le chemin suivi ` travers un algorithme est appel le ux
u
e ee
a
e
e
dinstructions (gure 2.6), et les constructions qui le modient sont appeles des instructions
de contrle de ux. On excute normalement les instructions de la premi`re ` la derni`re, sauf
o
e
e a
e
lorsquon rencontre une instruction de contrle de ux : de telles instructions vont permettre
o
de suivre dirents chemins suivant les circonstances. Cest en particulier le cas de linstruce
tion conditionnelle qui nexcute une instruction que sous certaines conditions pralables. Nous
e
e
distinguerons ici 3 variantes dinstructions conditionnelles (gure 2.7) :
test simple
Instructions conditionnelles
if condition : blocIf
alternative simple
Remarque 2.9 : A propos des instructions conditionnelles, on parle souvent des instructions if dans le
jargon des informaticiens.
Remarque 2.10 :
else : if ....
elif ... et la contraction de
else : blocElse
alternative multiple
elif condition1 : blocElif1
...
else : blocElse
o` if, else et elif sont des mots rservs, condition une expression boolenne (` valeur True
u
e
e
e
a
ou False) et bloc... un bloc dinstructions.
2.3. TESTS
2.3.1
47
Tests simples
Linstruction if sous sa forme la plus simple (gure 2.8) permet de tester la validit
e
dune condition. Si la condition est vraie, alors le bloc dinstructions blocIf apr`s le : est
e
excut. Si la condition est fausse, on passe ` linstruction suivante dans le ux dinstructions.
e e
a
Fig. 2.8 : Le test simple
Dnition 2.3 : test simple

e
Le test simple est une instruction de contrle du ux dinstructions qui permet dexcuter une
o
e
instruction sous condition pralable.
e
Fig. 2.9 : Principaux operateurs Python

Oprateurs logiques : not a, a and b, a or b
e
La condition value apr`s linstruction if est donc une expression boolenne qui prend
e
e
e
e
soit la valeur False (faux) soit la valeur True (vrai). Elle peut contenir les oprateurs de come
paraison suivants :
x == y
x != y
x > y
x < y
x >= y
x <= y
#
#
#
#
#
#
x
x
x
x
x
x
est
est
est
est
est
est
gal ` y
e
a
dirent de y
e
plus grand que y
plus petit que y
plus grand que, ou gal ` y
e
a
plus petit que, ou gal ` y
e
a
Mais certains probl`mes exigent parfois de formuler des conditions qui ne peuvent pas tre
e
e
exprimes sous la forme dune simple comparaison. Par exemple, la condition x [0, 1[ sexprime
e
par la combinaison de deux conditions x 0 et x < 1 qui doivent tre vries en mme temps.
e
e e
e
Pour combiner ces conditions, on utilise les oprateurs logiques not, and et or (gure 2.9). Ainsi
e
TD2.5
la condition x [0, 1[ pourra scrire en Python : (x >= 0) and (x < 1).
e
Oprateurs de comparaison : x == y, x != y,
e
x < y, x <= y, x > y, x >= y
Oprateurs arithmtiques : +x, -x, x + y,
e
e
x - y, x * y, x / y, x % y, x**y
TD 2.5 : Operateurs booleens derives (1)

En utilisant les oprateurs boolens de base (not, and et
e
e
or), ecrire un algorithme qui aecte successivement ` une
a
variable s le rsultat des oprations boolennes suivantes :
e
e
e
ou exclusif (xor, ab), non ou (nor, a + b), non et (nand,
a b), implication (a b) et quivalence (a b).
e
TD 2.6 : Circuit logique (1)

Donner les squences daectations permettant de calcue
ler la sortie s du circuit logique suivant en fonction de
ses entres a, b et c.
e
Le tableau ci-dessous donne les tables de vrit des oprateurs not, or et and, leur reprsentae e
e
e
tion graphique traditionnelle ainsi que leurs principales proprits.
ee
TD2.6
a b c
48
ngation
e
not a
TD 2.7 : Lois de De Morgan

Dmontrer ` laide des tables de vrit les lois de De
e
a
e e
Morgan a, b {0; 1} :
1. (a + b) = a b
2. (a b) = a + b
Fig. 2.10 : Lalternative simple

else : blocElse
Remarque 2.11 : Le test simple (gure 2.8 page 47)

est quivalent ` une alternative simple o` on explicite
e
a
u
le fait de ne rien faire (instruction pass) dans le bloc
dinstructions associ au else :
e
if condition : bloc
else : pass
voir galement le TD 2.30 page 70.
e
conjonction
a and b
a b ab
0 0
0
0 1
0
1 0
0
1 1
1
not (a or b)
a a
0 1
1 0
disjonction
a or b
a b a+b
0 0
0
0 1
1
1 0
1
1 1
1
not (a and b)
a, b, c {0; 1} :
a+0=a
a1=a
a+1=1
a0=0
a+a=a
aa=a
a+a=1
aa=0
a + (a b) = a
a (a + b) = a
a=a
a+b=ab
ab=a+b
(a + b) = (b + a)
(a b) = (b a)
(a + b) + c = a + (b + c)
(a b) c = a (b c)
a + (b c) = (a + b) (a + c)
a (b + c) = (a b) + (a c)
TD2.7
2.3.2
Alternatives simples
Exemple 2.4 : Extrait dun dialogue entre un conducteur egare et un pieton

Pourriez-vous mindiquer le chemin de la gare, sil vous plait ?
Oui bien sr : vous allez tout droit jusquau prochain carrefour. Si la rue ` droite est
u
a
autorise ` la circulation hier elle tait en travaux alors prenez la et ensuite cest
e a
e
la deuxi`me ` gauche et vous verrez la gare. Sinon, au carrefour, vous allez tout droit et
e
a
vous prenez la premi`re ` droite, puis encore la premi`re ` droite et vous y tes.
e a
e a
e
Merci.
Lalgorithme dcrit par le piton propose une alternative entre deux solutions. Le conducteur
e
e
gar devra tester si la rue est en travaux avant de prendre la dcision daller ` droite au carrefour
e e
e
a
ou de continuer tout droit. En algorithmique, un tel choix est propos par lalternative simple,
e
instruction conditionnelle dite if . . . else .
Linstruction if . . . else teste une condition (gure 2.10). Si la condition est vraie, alors
le bloc dinstructions blocIf apr`s le : est excut. Si la condition est fausse, cest le bloc
e
e e
dinstructions blocElse apr`s le else : (sinon) qui est excut. Seul lun des 2 blocs est
e
e e
donc excut.
e e
2.3. TESTS
49
Dnition 2.4 : alternative simple

e
Lalternative simple est une instruction de contrle du ux dinstructions qui permet de choisir
o
entre deux instructions selon quune condition est vrie ou non.
e e
Exemple 2.5 : Valeur absolue dun nombre
Lalgorithme qui dtermine la valeur absolue y dun nombre x peut scrire de la mani`re suie
e
e
vante :
if x < 0 : y = -x
else : y = x
On commence par tester le signe de x (if x < 0), si x < 0, alors la valeur absolue y vaut x
( : y = -x) sinon (x 0) elle vaut x (else : y = x).
TD2.8
Exemple 2.6 : Fonction porte
y
On consid`re la fonction porte f dont le graphe est donn cie

e
contre. Lalternative suivante permet de calculer y = f (x) :
TD 2.8 : Maximum de 2 nombres

Ecrire un algorithme qui dtermine le maximum m de 2
e
nombres x et y.
TD 2.9 : Fonction porte
Proposer une autre alternative simple pour calculer la
fonction porte de lexemple 2.6 ci-contre.
Fig. 2.11 : Aiguillage if ... else

else : blocElse
[condition]
blocIf
[else]
blocElse
if x < -1 or x > 2 : y = 0
else : y = 2
TD2.9
x
1 0
Les exemples 2.4 et 2.6 prcdents nous montrent quune alternative se comporte comme un
e e
aiguillage de chemin de fer dans le ux dinstructions (gure 2.11). Un if ... else ouvre
deux voies correspondant ` deux traitements dirents, et seule une de ces voies sera emprunte
a
e
e
(un seul des deux traitements est excut). Mais il y a des situations o` deux voies ne susent
e e
u
pas : on utilise alors des alternatives simples en cascade (ou alternatives multiples).
2.3.3
Alternatives multiples
Exemple 2.7 : Etat de leau

A pression ambiante, leau est sous forme de glace si la temprature est infrieure ` 0 C, sous
e
e
a
C et 100 C et sous forme de vapeur
forme de liquide si la temprature est comprise entre 0
e
au-del` de 100 C.
a
Ltiquette [condition] signie quon passe par

e
la voie correspondante si la condition est vrie
e e
(True), sinon on passe par la voie tiquette [else].
e
e
Fig. 2.12 : if ... else imbriques

if condition1 : blocIf1
else :
if condition2 : blocIf2
else : blocElse
[condition1]
[else]
Un algorithme qui devrait dterminer ltat de leau en fonction de la temprature doit pouvoir
e
e
e
choisir entre trois rponses possibles : solide, liquide ou vapeur. Une premi`re version de cet
e
e
blocIf1
[condition2]
[else]
blocIf2
blocElse
50
algorithme utilise 3 tests simples :

TD 2.10 : Ouverture dun guichet
A laide dalternatives simples imbriques, crire un ale
e
gorithme qui dtermine si un guichet est ouvert ou
e
ferm selon les jours de la semaine (lundi, mardi,
e
. . . ,dimanche) et lheure de la journe (entre 0h et
e
24h). Le guichet est ouvert tous les jours de 8h ` 13h et
a
de 14h ` 17h sauf le samedi apr`s-midi et toute la journe
a
e
e
du dimanche.
if t < 0 : eau = glace

if t >= 0 and t <= 100 : eau = liquide
if t > 100 : eau = vapeur
Cet algorithme est correct mais va valuer les 3 conditions qui portent sur la mme variable t
e
e
et qui sont exclusives les unes des autres ; en eet, si (t < 0), alors on ne peut pas avoir (t
>= 0 and t <= 100) ni (t > 100). Il est donc inutile dvaluer les 2 derni`res conditions si la
e
e
premi`re est vrie, ou dvaluer la derni`re condition si la deuxi`me est vrie. On prf`re
e
e e
e
e
e
e e
ee
donc imbriquer les tests de la mani`re suivante :
e
Fig. 2.13 : Lalternative multiple

...
else : blocElse
[condition]
[condition1]
blocIf
blocElif1
[condition2]
blocElif2
else :
if t <= 100 : eau = liquide
else : eau = vapeur
TD2.10
On commence par valuer la premi`re condition (t < 0). Si la condition est vrie, on excute
e
e
e e
e
laectation eau = glace ; sinon (t >= 0), on value la deuxi`me condition (t <= 100) qui
e
e
en fait est quivalente ` (t >= 0) and (t <= 100). Si la condition est vrie, on excute
e
a
e e
e
laectation eau = liquide ; sinon (t > 100), on excute laectation eau = vapeur. La
e
gure 2.12 illustre le contrle du ux dinstructions lors de deux if ... else imbriqus :
o
e
il sagit de deux aiguillages en cascade. An de simplier lcriture des tests imbriqus, on peut
e
e
contracter le else : if en elif et obtenir une version plus compacte de lalgorithme, strictement quivalente ` la version prcdente :
e
a
e e
elif t <= 100 : eau = liquide
else : eau = vapeur
[else]
blocElse
Lalternative multiple ci-dessus est quivalente ` un

e
a
ensemble dalternatives simples imbriques :
e
else :
if condition1 : blocElif1
else :
if condition2 : blocElif2
else :
..
.
else : blocElse
Linstruction if . . . elif teste une premi`re condition (gure 2.13). Si cette condition
e
est vraie, alors le bloc dinstructions blocIf est excut. Si la premi`re condition est fausse,
e e
e
on teste la deuxi`me (condition1). Si la deuxi`me condition est vrie, cest le bloc dinse
e
e e
tructions blocElif1 apr`s le premier elif : (sinon-si) qui est excut ; sinon on teste la
e
e e
condition suivante (condition2). Si elle est vrie, cest le bloc dinstructions blocElif2 apr`s
e e
e
le deuxi`me elif : qui est excut et ainsi de suite. Si aucune des conditions nest vrie,
e
e e
e e
cest le bloc dinstructions blocElse qui est excut. Dans tous les cas, un seul des blocs est
e e
donc excut.
e e
2.4. BOUCLES
51
Dnition 2.5 : alternative multiple

e
Lalternative multiple est une instruction de contrle du ux dinstructions qui permet de choisir
o
entre plusieurs instructions en cascadant des alternatives simples.
Exemple 2.8 : Mentions du baccalaureat

Au baccalaurat, la mention associe ` une note sur 20 est tr`s bien pour les notes suprieures
e
e a
e
e
ou gales ` 16, bien pour les notes comprises entre 14 inclus et 16 exclu, assez bien pour
e
a
les notes comprises entre 12 inclus et 14 exclu, passable pour les notes comprises entre 10
inclus et 12 exclu et insuffisant pour les notes strictement infrieures ` 10.
e
a
On peut utiliser une alternative multiple pour dterminer la mention au bac en fonction de la
e
note :
if note < 10 : mention = insuffisant
elif note < 12 : mention = passable
elif note < 14 : mention = assez bien
elif note < 16 : mention = bien
else : mention = tr`s bien
e
TD2.11
2.4
Boucles

Le plus grand commun diviseur de 2 entiers a et b peut se calculer en appliquant la relation de
rcurrence pgcd(a, b) = pgcd(b, a%b) jusqu` ce que le reste (a%b) soit nul.
e
a
Dans lexemple 2.3 page 45, pour calculer le pgcd de a = 12 et de b = 18, on appliquait 3 fois de
suite cette relation : pgcd(12, 18) = pgcd(18, 12) = pgcd(12, 6) = pgcd(6, 0) = 6. Lalgorithme
correspondant faisait donc appara 3 fois de suite les mmes instructions apr`s linitialisation
tre
e
e
des variables a et b :
r = a%b
a = b
b = r
Si nous voulons maintenant calculer le pgcd de 44 et 5648, il nous faudra rpter 5 fois la mme
e e
e
squence dinstructions pour trouver que pgcd(44, 5648) = 4.
e
Ce nouvel exemple de calcul de pgcd soul`ve au moins 2 questions :
e
TD 2.11 : Categorie sportive

Ecrire un algorithme qui dtermine la catgorie sportive
e
e
dun enfant selon son ge :
a
Poussin de 6 ` 7 ans,
a
Pupille de 8 ` 9 ans,
a
Minime de 10 ` 11 ans,
a
Cadet de 12 ans ` 14 ans.
a
52

1. Comment viter de rpter explicitement plusieurs fois de suite la mme squence dinse
e e
e
e
tructions ?
2. Comment viter de savoir ` lavance combien de fois il faut rpter la squence pour obtenir
e
a
e e
e
le bon rsultat ?
e
ITERATION n. f. XVe si`cle. Emprunt du latin

e
e
iteratio, rptition, redite . Rptition. MATH.
e e
e e
Rptition dun calcul avec modication de la vae e
riable, qui permet dobtenir par approximations successives un rsultat satisfaisant.
e
De nouvelles instructions de contrle de ux sont introduites pour rpondre ` ces questions :

o
e
a
les instructions itratives. On parle galement de boucles, de rptitions ou encore ditrations
e
e
e e
e
e
(gure 2.14). Nous distinguerons 2 variantes dinstructions itratives :
Instructions itratives
e
itration conditionnelle while condition : blocWhile
e
parcours de squence
e
Remarque 2.12 : A propos des instructions itratives,

e
on parle souvent des boucles while ou des boucles
for dans le jargon des informaticiens.
for element in sequence : blocFor
o` while, for et in sont des mots rservs, condition une expression boolenne (` valeur True
u
e
e
e
a
ou False), element un lment de la squence sequence et bloc... un bloc dinstructions.
ee
e
2.4.1
Fig. 2.15 : Boucle while
while condition : blocWhile
[condition]
blocWhile
Itration conditionnelle
e
Linstruction while permet de rpter plusieurs fois une mme instruction (gure 2.15) :
e e
e
le bloc dinstructions blocWhile est excut tant que (while) la condition est vrie. On arrte
e e
e e
e
d`s que la condition est fausse ; on dit alors quon sort de la boucle.
e
On commence par tester la condition ; si elle est vrie, on excute le bloc dinstructions
e e
e
blocWhile (encore appel le corps de la boucle) puis on reteste la condition : la condition
e
est ainsi value avant chaque excution du corps de la boucle ; si la condition est ` nouveau
e
e
e
a
vrie on rexcute le bloc dinstructions blocWhile (on dit quon repasse dans la boucle)
e e
e e
et ainsi de suite jusqu` ce que la condition devienne fausse, auquel cas on sort de la boucle.
a
[not condition]
Dnition 2.6 : iteration conditionnelle

e
Litration conditionnelle est une instruction de contrle du ux dinstructions qui permet sous
e
o
condition pralable de rpter zro ou plusieurs fois la mme instruction.
e
e e
e
e
2.4. BOUCLES
53
Exemple 2.10 : Table de multiplication

On cherche ` crire un algorithme qui ache la table de multiplication dun nombre n quelconque.
ae
Lachage ci-contre est obtenu par lalgorithme
Exemple : n = 9 1 * 9 = 9
2 * 9 = 18
suivant : n = 9
3
4
5
6
7
8
9
*
*
*
*
*
*
*
9
9
9
9
9
9
9
=
=
=
=
=
=
=
27
36
45
54
63
72
81
i = 1
while i < 10:
print(i, *, n, =, i*n)
i = i + 1
Lalgorithme prcdent commence par initialiser n et le multiplicateur i. Ensuite, puisque i <

e e
10, on rentre dans la boucle ; la premi`re instruction print ache successivement la valeur de i,
e
une *, la valeur de n, le signe = puis la valeur du produit i*n, soit au premier passage : 1 * 9 =
9. Linstruction suivante incrmente i qui devient ainsi gal ` 2 (1 + 1). Les deux instructions
e
e
a
du corps de la boucle while ayant t excutes, on reteste la condition i < 10 ; elle est `
ee e e
a
nouveau vrie puisque i vaut maintenant 2. On repasse alors dans la boucle o` on ache 2 *
e e
u
9 = 18 et o` on incrmente i qui vaut maintenant 3 (2 + 1). On rit`re ces oprations jusqu`
u
e
e e
e
a
ce que i soit gal ` 10 (9 + 1) ; entre-temps les 7 autres lignes de la table de multiplication par
e
a
9 ont t aches. Lorsque i vaut 10, la condition i < 10 nest plus vrie et on sort de
ee
e
e e
la boucle while.
TD2.12
Dans une itration conditionnelle, la condition doit voluer au cours des dirents passages
e
e
e
dans la boucle an de pouvoir sortir de la boucle. Cest le cas de la boucle while de lexemple
2.10 ci-dessus ; ` chaque passage dans la boucle, le multiplicateur i est incrment : ainsi, partant
a
e
e
de la valeur initiale i = 1, i deviendra ncessairement gal ` 10 apr`s 9 passages dans la boucle.
e
e
a
e
En ce qui concerne le nombre de passages dans la boucle, deux cas extr`mes peuvent se
e
produire :
la condition nest pas vrie la premi`re fois : on ne passe alors jamais dans la boucle.
e e
e
x est positif ; la condition x < 0 nest donc pas vrie
e e
Exemple : x = 4
y = 0
while x < 0 : y = y + x
la premi`re fois : on ne rentre pas dans la boucle.

e
la condition nest jamais fausse : on ne sort jamais de la boucle ; on dit quon a aaire `
a
une boucle sans n .
TD 2.12 : Dessin detoiles (1)

Ecrire un algorithme itratif qui ache les n lignes suie
vantes (lexemple est donn ici pour n = 6) :
e
Rappel Python :
******
>>> 5*r
****
rrrrr
***
>>> 2*to
**
toto
*
54

Exemple : x = 4
y est initialement nul : on rentre dans la boucle ; linstruction du corps de la boucle ne peut quincrmenter
e
y puisque x est positif : y sera donc toujours positif
et on ne sortira jamais de la boucle.
y = 0
while y >= 0 : y = y + x
Remarque 2.13 : Une erreur classique de lapprenti

informaticien est de ne pas faire voluer la condition
e
dune boucle while : il tombe alors dans une boucle
sans n comme dans lexemple ci-dessous :
On entre dans la boucle ; on calk = 1
cule la nouvelle valeur de p puis on
p = x
reteste la condition k <= n. Mais
while k < n :
entre-temps k na pas volu (il
e
e
p = p*x
na pas t incrment) et donc la
ee
e
e
condition reste vraie et restera toujours vraie : lexcution ne sortira
e
plus de la boucle.
TD 2.13 : Fonction factorielle
Ecrire un algorithme qui calcule n! = 123. . .(n1)n.
Le cas de la boucle sans n est videmment d le plus souvent ` une erreur involontaire
e
u
a
quil faut savoir dtecter assez vite pour viter un programme qui tourne indniment sans
e
e
e
sarrter.
e
Exemple 2.11 : Fonction puissance
La puissance enti`re p dun nombre x est dnie par : p = xn =
e
e
x = x x xx .
k=1
n fois
Pour calculer p de tte , nous calculons successivement x, x2 , x3 . . ., xn1 et xn en mmorisant

e
e
a
` chaque tape la puissance courante xk et en multipliant simplement cette puissance par x pour
e
obtenir la puissance immdiatement suprieure xk+1 . On sarrte quand k = n : on a alors le
e
e
e
n ). Cet algorithme peut scrire directement :
rsultat attendu (p = x
e
e
k = 1
p = x
while k < n:
p = p*x
k = k + 1
On commence par initialis lexposant k ` 1 et la puissance p recherche avec la

e
a
e
valeur de xk = x1 = x (p = x). Ensuite, pour chaque valeur de k < n, on multiplie
la puissance courante p par x (p*x) qui devient la nouvelle puissance courante (p =
p*x) et on noublie pas dincrmenter lexposant k ; ainsi ` la n de chaque itration,
e
a
e
on a toujours p = xk k [1; n].
TD2.13
Dans les exemples 2.10 et 2.11 prcdents, on savait ` lavance combien de fois on devait
e e
a
passer dans les boucles : 9 fois pour acher une table de multiplication et n fois pour calculer
xn . Mais ce nest pas toujours le cas comme nous allons le constater dans les deux exemples
suivants qui permettent de calculer respectivement la fonction exponentielle (exemple 2.12 : ex )
et le pgcd de 2 nombres (exemple 2.13 : pgcd(a, b)).
Exemple 2.12 : Fonction exponentielle
La fonction exponentielle peut tre calcule en fonction de son dveloppement en srie enti`re.
e
e
e
e
e
n
y = exp(x)
uk =
k=0
k=0
x2
xn
xk
=1+x+
+ ... +
k!
2
n!
Les calculs seront arrts lorsque la valeur absolue du terme uk sera infrieure ` un certain seuil
ee
e
a
s (0 < s < 1). On nutilisera ni la fonction puissance (xn ) ni la fonction factorielle (n!) pour
eectuer le calcul de exp(x).
2.4. BOUCLES
55
Pour ce calcul, on pourrait avoir la mme dmarche que dans lexemple 2.11 de la puissance
e
e
enti`re ; ` savoir, on calcule le premier terme de la srie (x0 /0! = 1), on le mmorise dans y, on
e
a
e
e
eme terme (x1 /1! = x) et on lajoute ` la valeur de y prcdemment mmorise (1+x),
`
calcule le 2
a
e e
e
e
`
on calcule le 3eme terme (x2 /2! = x2 /2), on lajoute ` y (1 + x + x2 /2) et ainsi de suite jusqu`
a
a
ce que le nouveau terme calcul vrie la condition darrt impose (|uk | < s). Mais chaque
e e
e
e
valuation dun nouveau terme fait intervenir a priori les fonctions puissance (xk ) et factorielle
e
(n!). . .qui sont tr`s coteuses en temps de calcul. On prf`re remarquer que le terme uk+1 peut
e
u
ee
sexprimer simplement en fonction du terme prcdent uk selon la relation de rcurrence :
e e
e
uk+1 =
x
xk
x
xk+1
=
=
uk
(k + 1)!
k + 1 k!
k+1
et quil est donc possible de mmoriser ` chaque tape uk pour calculer le terme suivant uk+1
e
a
e
sans utiliser ni la fonction puissance, ni la fonction factorielle. On obtient alors lalgorithme
suivant :
k = 0
u = 1
y = u
while
u
y
k
fabs(u) > s:
= u*x/(k+1)
= y + u
= k + 1
On initialise lindice k ` 0, le terme u (= uk ) ` la valeur du premier terme de la srie

a
a
e
(x0 /0! = 1) et y ` ce premier terme (y = u). Puis, tant que la valeur absolue de uk
a
(fabs(u)) est suprieure au seuil s, on calcule le terme suivant uk+1 en utilisant la
e
relation de rcurrence obtenue ci-dessus (u = u*x/(k+1)) : le nouveau terme uk+1 est
e
gal ` lancien terme uk multipli par x/(k + 1) ; on ajoute uk+1 ` la somme courante
e
a
e
a
y (y = y + u) et on recommence sans oublier dincrmenter k (k = k + 1). A la n
e
k
X
de chaque itration, on a toujours y =
e
ui .
i=0
Ici, on connait la condition darrt de la boucle (|uk | < s) mais on ne sait pas a priori come
bien de fois on passera dans la boucle : on ne connait pas lordre n pour lequel on arrtera le
e
TD2.14
dveloppement de la srie enti`re.
e
e
e

On consid`re ` nouveau la relation de rcurrence qui caractrise le pgcd de 2 entiers a et b (voir
e a
e
e
exemples 2.3 et 2.9) : pgcd(a, b) = pgcd(b, a%b). Cette relation nous dit de remplacer a par b et
b par r = a%b autant de fois que possible jusqu` ce que le reste soit nul (pgcd(a, 0) = a). Ce
a
qui conduit ` lalgorithme suivant :
a
TD 2.14 : Fonction sinus

Ecrire un algorithme qui calcule de mani`re itrative la
e
e
fonction sinus en fonction de son dveloppement en srie
e
e
enti`re.
e
n
n
X
X
x2k+1
sin(x)
uk =
(1)k
(2k + 1)!
k=0
k=0
x3
x5
x2n+1
+
+ . . . + (1)n
6
120
(2n + 1)!
Les calculs seront arrts lorsque la valeur absolue du
ee
terme uk sera infrieure ` un certain seuil s (0 < s < 1).
e
a
On nutilisera ni la fonction puissance (xn ) ni la fonction
factorielle (n!) pour eectuer le calcul de sin(x).
=x
56
while
r
a
b

b
=
=
=
!= 0:
a%b
b
r
A la n de chaque passage dans le corps de la boucle, a, b et r prennent successivement

les valeurs suivantes (r nest pas connu avant la boucle) :
avant la boucle
1er passage
`
2eme passage
eme
3 ` passage
apr`s la boucle
e
Fig. 2.16 : Euclide

Euclide (n vers -325, mort vers -265) tait un
e
e
mathmaticien de la Gr`ce antique, auteur des
e
e
e
Elments , qui sont considrs comme lun des
e e
textes fondateurs des mathmatiques modernes. En
e
particulier, le livre 7 traite de larithmtique : il y
e
dnit la division que lon appelle division euclie
dienne et un algorithme pour calculer le plus grand
commun diviseur de deux nombres, connu sous le
nom dalgorithme dEuclide.
TD 2.15 : Algorithme dEuclide

Dans la tradition grecque, en comprenant un nombre entier comme une longueur, un couple dentiers comme un
rectangle, leur pgcd est la taille du plus grand carr pere
mettant de carreler ce rectangle. Lalgorithme dcompose
e
ce rectangle en carrs, de plus en plus petits, par divie
sions euclidiennes successives, de la longueur par la largeur, puis de la largeur par le reste, jusqu` un reste nul.
a
Faire la construction gomtrique ` la grecque antique
e e
a
qui permet de dterminer le pgcd d de a = 21 et b = 15
e
(d = 3).
`
TD 2.16 : Division entiere
Ecrire un algorithme itratif qui calcule le quotient q et
e
le reste r de la division enti`re a b (a = bq + r).
e
On nutilisera pas les oprateurs prdnis / et % mais
e
e e
on pourra sinspirer du TD 2.4 page 45.
a
12
18
12
6
6
b
18
12
6
0
0
r
?
12
6
0
0
Cet algorithme de calcul de pgcd est connu sous le nom dalgorithme dEuclide (gure 2.16) et
fait partie des grands classiques de lalgorithmique.
TD2.15
L` encore, la condition darrt est connue (b = 0) mais pas le nombre de passages dans la boucle.
a
e
TD2.16
Dans tous les cas, que lon connaisse ou non a priori le nombre de passages dans la boucle,
on peut toujours utiliser litration conditionnelle (boucle while) pour rpter plusieurs fois un
e
e e
bloc dinstructions ` condition de conna la condition darrt pour sortir de la boucle.
a
tre
e
Lorsquon conna a priori le nombre de passages dans la boucle (voir exemples 2.10 et
t
2.11), il sut de dnir un compteur qui compte le nombre de fois o` on passe dans la
e
u
boucle : le multiplicateur i dans lexemple de la table de multiplication et lexposant k
dans le calcul de la puissance. On initialise correctement ce compteur avant la boucle (i
= 1 ou k = 1 selon lexemple considr), on incrmente le compteur dans la boucle (i =
ee
e
i + 1 ou k = k + 1) et on sort de la boucle lorsque ce compteur dpasse le nombre de
e
fois connu o` on doit passer dans la boucle (i < 10 ou k <= n).
u
Lorsquon ne conna pas a priori le nombre de passages dans la boucle (voir exemples
t
2.12 et 2.13), il faut absolument dterminer la condition darrt de lalgorithme : |uk | < s
e
e
pour le calcul de ex et b = 0 dans lexemple du pgcd. Il faut galement sassurer que cette
e
condition sera bien atteinte au bout dun certain nombre de passages dans la boucle : dans
le calcul du pgcd par exemple, le reste r de la division a b ne peut tre quinfrieur au
e
e
diviseur b et comme b est remplac par r dans le corps de la boucle, b ne peut que diminuer
e
et atteindre 0 au bout du compte.
2.4.2
Parcours de squences
e
Il est frquent de manipuler des suites ordonnes dlments comme les cha
e
e
ee
nes de caract`res
e
(exemple : s = "123"), les tableaux (exemple : t = [1,2,3]) et les n-uplets (exemple : u =
2.4. BOUCLES
57
1,2,3). Chaque lment dune squence est accessible par son rang dans la squence grce `
ee
e
e
a a
loprateur crochets : sequence[rang] (exemples : s[1], t[2] ou u[0]) et par convention,
e
`
le premier lment dune squence a le rang 0 (exemples : s[1] est le 2eme lment de la cha
ee
e
ee
ne
eme lment du tableau t et u[0] le 1er lment du n-uplet u).
`
s, t[2] le 3
ee
ee
>>> s = "123"
>>> s[1]
2
>>> t = [1,2,3]
>>> t[2]
3
>>> u = 1,2,3
>>> u[0]
1
Dnition 2.7 : sequence

e
Une squence est une suite ordonne dlments, ventuellement vide, accessibles par leur rang
e
e
ee
e
dans la squence.
e
Les principales oprations sur les squences sont listes dans le tableau ci-dessous (dapr`s [10]).
e
e
e
e
Operation
x in s
x not in s
s1 + s2
s * n, n*s
s[i]
s[i : j]
s[i : j :step]
len(s)
min(s)
max(s)
range([start,] end [, step])
Result
True if an item of s is equal to x, else False
False if an item of s is equal to x, else True
the concatenation of s1 and s2
n copies of s concatenated
ith item of s, origin 0
Slice of s from i (included) to j(excluded). Optional
step value, possibly negative (default : 1).
Length of s
Smallest item of s
Largest item of s
Returns list of ints from >= start and < end.
With 1 arg, list from 0..arg-1
With 2 args, list from start..end-1
With 3 args, list from start up to end by step
La derni`re fonction de ce tableau cre un tableau dentiers compris entre start inclus (= 0 par
e
e
dfaut) et end exclus par pas de step (= 1 par dfaut).
e
e
Remarque 2.14 : Les lments dune cha

ee
ne de caract`res sont eux-mmes des cha
e
e
nes de caract`res ` 1
e
a
seul caract`re.
e
>>> s = a4b2
>>> s[1]
4
>>> s[3]
2
58

>>>
[0,
>>>
[3,
>>>
[7,
TD 2.17 : Affichage inverse

Ecrire un algorithme qui ache les caract`res dune
e
cha s, un par ligne en partant de la n de la cha
ne
ne.
TD 2.18 : Parcours inverse
Ecrire un algorithme qui parcourt en sens inverse une
squence s quelconque (du dernier lment au premier
e
ee
lment).
ee
[i < len(s)]
>>>
>>>
[0,
>>>
>>>
[6,
s = "bonjour"
range(len(s))
1, 2, 3, 4, 5, 6]
t = [4,2,6,5,3]
range(max(t),min(t),-1)
5, 4, 3]
>>>
>>>
>>>
[0,
>>>
[0,
u1 = 10,12,14
u2 = a,b,c
range(len(u1+u2))
1, 2, 3, 4, 5]
range(len(2*u2[0:2]))
1, 2, 3]
`
`
Exemple 2.14 : Affichage caractere par caractere
Lalgorithme suivant ache les caract`res dune cha s, un par ligne :
e
ne
i = 0
while i < len(s) :
print(s[i])
i = i + 1
On se place au dbut de la cha (rang i = 0) et, tant quon est

e
ne
a
` lintrieur de la cha (i < len(s)), on ache llment courant
e
ne
ee
s[i]. Le rang i prend successivement les valeurs 0, 1, 2 . . . len(s)-1
(len(s) exclus).
TD2.17
Lachage prcdent nous a conduits ` parcourir la cha s du premier lment (i = 0) au

e e
a
ne
ee
dernier lment (i = len(s)-1). On peut gnraliser cet exemple au parcours dune squence
ee
e e
e
s quelconque, du premier lment au dernier lment (parcours direct) :
ee
ee
Fig. 2.17 : Boucle for

for element in s : blocFor
i = 0
range(3)
1, 2]
range(3,9,2)
5, 7]
range(7,0,-1)
6, 5, 4, 3, 2, 1]
element = s[i]
blocFor
i = i + 1
[i >= len(s)]

1. Ecrire un algorithme qui calcule de mani`re
e
Pn
itrative la somme s =
e
0 uk des n premiers
termes dune suite arithmtique uk = a + r k.
e
On utilisera une boucle for.
2. Comparer lecacit de cette approche itrative
e
e
avec le calcul du TD 2.2 page 44.
i = 0
while i < len(s):
# traiter s[i]
i = i + 1
Se placer au dbut de la squence : initialiser un entier i qui

e
e
reprsentera le rang dans la squence (rang initial : i = 0) ; puis
e
e
tant quon est dans la squence (condition : 0 <= i < len(s)), traie
ter llment courant s[i] et passer ` llment suivant (i = i + 1).
ee
a ee
TD2.18
Il existe une instruction de contrle adapte au parcours de squence (gure 2.17) :

o
e
e
for element in sequence : blocFor
quivalente ` : i = 0
e
a
while i < len(s):
element = sequence[i]
blocFor
i = i + 1
Ainsi, lalgorithme de lexemple 2.14 ci-dessus peur se rcrire simplement sous la forme :
ee
for element in s : print(element)
De mme, lalgorithme de calcul de la fonction puissance (exemple 2.11) peut scrire avec une
e
e
boucle for :
p = x
for i in range(n) : p = p*x
TD2.19
2.4. BOUCLES
2.4.3
59
Imbrications de boucles
De la mme mani`re que lon peut cascader des alternatives simples (voir section 2.3.3), on
e
e
peut encapsuler une boucle dans une autre boucle.
Exemple 2.15 : Tables de multiplication
Nous avons ach une table de multiplication dans lexemple 2.10 page 52. Nous voulons maine
tenant acher les 9 premi`res tables de multiplication en rutilisant lalgorithme dachage
e
e
dune seule table. Il nous sut pour cela de rpter 9 fois lalgorithme dachage dune table
e e
en incrmentant le multiplicande n ` chaque itration :
e
a
e
n = 1
while n <= 9:
i = 1
while i < 10:
print(i, *, n, =, i*n)
i = i + 1
n = n + 1
On initialise n ` 1 (on commence par la table de multiplication de

a
1), puis on entre dans la boucle qui fera varier n de 1 ` 9 (while
a
n <= 9). On excute lalgorithme dachage dune table (exemple
e
2.10) et ` la sortie de cet algorithme, on noublie pas dincrmenter
a
e
n (n = n + 1) pour passer ` la table suivante. Et ainsi de suite
a
jusqu` la table de 9. Quand n = 9, son incrmentation lui aecte
a
e
la valeur 10, ce qui rend fausse la condition de la boucle (n <= 9) :
on sort alors de la boucle extrieure.
e
TD2.20
Cet exemple dinstruction compose pose explicitement le probl`me de la dnition dun bloc
e
e
e
dinstructions : o` commence et o` termine un bloc dinstructions ? En eet, linstruction n =
u
u
n + 1 fait-elle partie du bloc de la boucle intrieure (while i < 10 :) ou du bloc de la boucle
e
extrieure (while n <= 9 :) ?
e
Les instructions composes ont toujours la mme structure : une ligne den-tte termine par
e
e
e
e
un double point ( :), suivie dune ou de plusieurs instructions indentes (dcales ` droite) sous
e
e e a
cette ligne den-tte (gure 2.18).
e
ligne den-t^te:
e
premi`re instruction du bloc
e
...
derni`re instruction du bloc
e
Sil y a plusieurs instructions indentes sous la ligne den-tte, elles doivent ltre exactement
e
e
e
au mme niveau (dcalage de 4 caract`res espace, par exemple). Ces instructions indentes
e
e
e
e
constituent ce quon appellera dsormais un bloc dinstructions. Un bloc dinstructions est une
e
suite dinstructions formant un ensemble logique, qui nest excut que dans certaines conditions
e e
dnies dans la ligne den-tte. Dans lexemple prcdent, les deux lignes dinstructions indentes
e
e
e e
e
sous la ligne contenant linstruction while i < 10 : constituent un mme bloc logique :
e
TD 2.20 : Dessin detoiles (2)

Reprendre le TD 2.12 page 53 en supposant quon ne peut
acher quune toile ` la fois (on sinterdit ici la possie
a
bilit dcrire 5** ` la place de ***** par exemple).
e e
a
Remarque 2.15 : Dans le langage Pascal, les blocs
dinstructions sont dlimits par les mots-cls explicites
e
e
e
begin ... end. En langage C, les blocs dinstructions
sont dlimits par des accolades ({ ... }). En Python,
e
e
les blocs sont caractriss par lindentation identique de
e e
chaque instruction du bloc.
Fig. 2.18 : Blocs dinstructions

bloc 1
instruction 1.1
...
instruction 1.n :
bloc 2
instruction 2.1
...
instruction 2.m :
bloc 3
instruction 3.1
...
fin bloc 3
instruction 2.(m+1)
...
fin bloc 2
instruction 1.(n+1)
...
fin bloc 1
60
ces deux lignes ne sont excutes toutes les deux que si la condition teste avec linstruction
e e
e
while est vrie, cest-`-dire si le multiplicateur i est tel que 1 <= i < 10.
e e
a
TD 2.21 : Operateurs booleens derives (2)

A laide ditrations imbriques, acher les tables de
e
e
vrit des oprateurs logiques drivs (voir TD 2.5) : ou
e e
e
e e
exclusif (xor, a b), non ou (nor, a + b), non et (nand,
a b), implication (a b) et quivalence (a b).
e
Exemple 2.16 : Tables de verite

Pour acher les tables de vrit des oprateurs logiques de base (voir section 2.3.1) : ngation
e e
e
e
(non, not, a), disjonction (ou, or, a + b) et conjonction (et, and, a b), on peut utiliser 2 boucles
for imbriques :
e
Exemple : a b
a
0
0
1
1
b ab
0
0
1
0
0
0
1
1
>>>
...
...
...
0 0
0 1
1 0
1 1
for a in [0,1]:
for b in [0,1]:
print(a, b, a and b)
0
0
0
1
TD2.21
111111111
000000000
111111111
000000000
111111111
000000000
111111111
000000000
111111111
000000000
111111111
000000000
Fig. 2.19 : Nid dabeilles
Exemple 2.17 : Nid dabeilles

Un motif en nid dabeilles est form de n m hexagones en quinconce comme sur la gure 2.19
e
ci-contre.
Pour dessiner un tel motif, il faut dabord savoir dessiner un hexagone de ct a en utilisant les
oe
instructions ` la Logo de lannexe 2.6.1 page 91 :
a
for k in range(6):
forward(a)
left(60)
puis une colonne de m hexagones de ct a ` labscisse x0 :

oe a
for j in range(m):
y0 = a*sqrt(3)*(1/2. - j)
up()
goto(-x0,-y0)
down()
for k in range(6):
forward(a)
left(60)
et enn n colonnes de m hexagones en quinconce :
2.4. BOUCLES
61
for i in range(n):
x0 = -3*i*a/2.
for j in range(m):
y0 = a*sqrt(3)*(1/2.*(i%2) - j)
up()
goto(-x0,-y0)
down()
for k in range(6):
forward(a)
left(60)
TD 2.22 : Damier
En utilisant les instructions ` la Logo de lannexe 2.6.1
a
page 91, dessiner un damier rectangulaire de nm cases.
TD2.22
2.4.4
Excutions de boucles
e
La ma
trise de lalgorithmique requiert deux qualits complmentaires [5] :
e
e
il faut avoir une certaine intuition, car aucun algorithme ne permet de savoir a priori
quelles instructions permettront dobtenir le rsultat recherch. Cest l` quintervient la
e
e
a
forme dintelligence requise pour lalgorithmique : la crativit de linformaticien. Il
e
e
y a des gens qui poss`dent au dpart davantage cette intuition que les autres. Cependant,
e
e
les rexes, cela sacquiert (en particulier, lannexe 2.6.3 page 95 prsente une mthode
e
e
e
pour aider ` construire des boucles). Et ce quon appelle lintuition nest nalement que de
a
lexprience accumule, tellement rpte que le raisonnement, au dpart laborieux, nit
e
e
e ee
e
par devenir spontan .
e
il faut tre mthodique et rigoureux. En eet, chaque fois quon crit une srie dinstruce
e
e
e
tions que lon croit justes, il faut systmatiquement se mettre mentalement ` la place de
e
a
la machine qui va les excuter (sur papier ou dans sa tte) an de vrier si le rsultat
e
e
e
e
obtenu est bien celui que lon voulait. Cette opration ne requiert pas dintuition. Mais elle
e
reste nanmoins indispensable si lon ne veut pas crire des algorithmes ` l aveuglette .
e
e
a
Et petit ` petit, ` force de pratique, on fera de plus en plus souvent lconomie de cette
a
a
e
derni`re tape : lexprience fera quon verra le rsultat produit par les instructions,
e e
e
e
au fur et ` mesure quon les crira. Naturellement, cet apprentissage est long, et demande
a
e
des heures de travail patient. Aussi, dans un premier temps, il faut viter de sauter les
e
tapes : la vrication mthodique, pas ` pas, de chacun des algorithmes reprsente plus
e
e
e
a
e
de la moiti du travail ` accomplir. . .et le gage de progr`s.
e
a
e
Pour amliorer la comprhension dune boucle, on peut tracer son excution de tte,
e
e
e
e
a
` la main ou par programme. Dans tous les cas, lide est de suivre pas ` pas lvolution des
e
a
e
Remarque 2.16 : Si en littrature lire, cest crire

e
e
dans sa tte , en algorithmique lire un algorithme,
e
cest lexcuter dans sa tte .
e
e
62
TD 2.23 : Trace de la fonction factorielle

Tracer la fonction factorielle du TD 2.13 page 54.
variables qui interviennent dans la boucle : on dtermine leur valeur juste avant la boucle, ` la
e
a
n de chaque itration et juste apr`s la boucle. Cest ce qui a t fait dans lexemple 2.13 page
e
e
ee
55 du calcul du pgcd ou on a pist les 3 variables concernes par ce calcul.
e
e
TD2.23
Exemple 2.18 : Execution dune boucle

Lexcution pas ` pas de lalgorithme ci-dessous donne le tableau de droite.
e
a
x = 2
n = 4
k = 1
p = x
while k < n:
p = p*x
k = k + 1

TD 2.24 : Figure geometrique
Que dessinent les instructions suivantes ?
x0 = 0
y0 = 0
r = 10
n = 5
m = 10
for i in range(n) :
up()
y = y0 - 2*r*i
x = x0 + r*(i%2)
goto(x,y)
for j in range(m) :
down()
circle(r)
up()
x = x + 2*r
goto(x,y)
Les variables concernes par la boucle sont essentiellement k et p (n et

e
x ne varient pas au cours de lalgorithme) :
avant
pendant
pendant
pendant
apr`s
e
k
1
2
3
4
4
p
2
4
8
16
16
Exemple 2.19 : Nombres de Fibonacci

Les nombres de Fibonacci sont donns par la suite
e
f0 = f1 = 1
fn = fn1 + fn2 n > 1
Les 10 premiers nombres de la suite de Fibonacci valent donc successivement f0 = 1, f1 = 1,
f2 = 2, f3 = 3, f4 = 5, f5 = 8, f6 = 13, f7 = 21, f8 = 34, et f9 = 55.
e
Le nombre fn (n > 1) de Fibonacci se calcule selon lalgorithme itratif suivant :
f, f1, f2 = 2,1,1
for i in range(3,n+1) :
f2 = f1
f1 = f
f = f1 + f2
On trace les 4 variables i, f2, f1 et

cas n = 9 :
i
avant
?
pendant 3
pendant 4
pendant 5
pendant 6
pendant 7
pendant 8
pendant 9
apr`s
e
9
f concernes par la boucle dans le

e
f2
1
1
2
3
5
8
13
21
21
f1
1
2
3
5
8
13
21
34
34
f
2
3
5
8
13
21
34
55
55
TD2.24

2.5
2.5.1
e
Conna
tre
TD 2.25 : QCM (2)

1. En Python, linstruction ne rien faire se dit
(a) break
(b) return
(c) pass
(d) continue
2. Une variable informatique est un objet
(a) quivalent ` une variable mathmatique
e
a
e
(b) qui associe un nom ` une valeur
a
(c) qui varie ncessairement
e
(d) qui modie la mmoire
e
3. Laectation consiste `
a
(a) comparer la valeur dune variable ` une autre valeur
a
(b) associer une valeur ` une variable
a
(c) incrmenter une variable
e
(d) dplacer une variable en mmoire
e
e
4. Apr`s la squence
e
e
a
b
b
a
=
=
=
=
(a) a = 13 et b = 13
(b) a = 4 et b = 4
(c) a = 4 et b = 13
(d) a = 13 et b = 4
13
4
a
b
les variables a et b sont telles que
63
64

5. Le rsultat dune comparaison est une valeur
e
(a) relle
e
(b) qui dpend du type des arguments
e
(c) boolenne
e
(d) enti`re
e
6. Un oprateur boolen sapplique ` des valeurs
e
e
a
(a) boolennes
e
(b) enti`res
e
(c) relles
e
(d) alphanumriques
e
7. La fonction principale dune instruction de test est
(a) de passer dinstruction en instruction
(b) de rpter une instruction sous condition
e e
(c) dexcuter une instruction sous condition
e
(d) dinterrompre lexcution dune instruction
e
8. Apr`s la squence
e
e
x = -3
if x <
elif x
elif x
elif x
else :
-4 : y = 0
< -3 : y = 4 - x
< -1 : y = x*x + 6*x + 8
< 3 : y = 2 - x
y = -2
la variable y est telle que
(a) y = -1
(b) y = 0
(c) y = 7
(d) y = -2
9. Litration conditionnelle est une instruction de contrle du ux dinstructions
e
o
(a) qui permet dexcuter une instruction sous condition pralable.
e
e
(b) qui est vrie tout au long de son excution.
e e
e

65
(c) qui permet sous condition pralable de rpter zro ou plusieurs fois la mme instruce
e e
e
e
tion.
(d) qui permet de choisir entre plusieurs instructions.
10. On ne sort jamais dune boucle si la condition darrt
e
(a) ne varie pas en cours dexcution.
e
(b) ne contient pas doprateurs boolens.
e
e
(c) est toujours fausse.
(d) nest jamais fausse.
11. Que vaut f ` la n des instructions suivantes si n = 5 ?
a
f = 0
i = 1
while i < n+1:
f = f + i
i = i + 1
(a) 6
(b) 10
(c) 15
(d) 21
12. Une squence est une suite ordonne
e
e
(a) dlments que lon peut rfrencer par leur rang.
ee
ee
(b) dinstructions formant un ensemble logique.
(c) dinstructions conditionnelles.
(d) de nombres
13. Dans la cha s = grard, s[2] vaut
ne
e
(a)
e
(b) r
(c) g
e
(d) gr
e
66

a
f = 1
f = f * i
(a) 120
(b) 720
(c) 6
(d) 24
a
f, f1, f2 = 2,1,1
f2 = f1
f1 = f
f = f1 + f2
(a) 3
(b) 5
(c) 8
(d) 13
2.5.2
Comprendre
TD 2.26 : Unite de longueur

Lanne-lumi`re (al) est une unit de distance utilise en astronomie. Une anne-lumi`re est la
e
e
e
e
e
e
distance parcourue par un photon (ou plus simplement la lumi`re) dans le vide, en dehors de
e
tout champ gravitationnel ou magntique, en une anne julienne (365,25 jours).
e
e
Ecrire une instruction qui permette de passer directement des annes-lumi`re aux m/s sae
e
chant que la vitesse de la lumi`re dans le vide est de 299 792 458 m/s.
e
TD 2.27 : Permutation circulaire (2)
Eectuer une permutation circulaire gauche entre les valeurs de 3 entiers x, y et z.
TD 2.28 : Sequence daffectations (2)

Quelles sont les valeurs des variables n et s apr`s la squence daectations suivante ?
e
e

67
n = 1
s = n
n = n + 1
s = s + n
n = n + 1
s = s + n
n = n + 1
s = s + n
n = n + 1
s = s + n
TD 2.29 : Circuits logiques (2)

On consid`re les conventions graphiques traditionnelles pour les oprateurs logiques :
e
e
ab
ab
a+b
abc
a+b+c
abc
Donner les squences daectations permettant de calculer la (ou les) sortie(s) des circuits loe
giques suivants en fonction de leurs entres.
e
1. a et b sont les entres, s la sortie.
e
2. a et b sont les entres, s la sortie.

e
a
s
s
b
68
3. a et b sont les entres, s et t les sore

ties.
6. a, b et c sont les entres, s et t les

e
sorties.
a
s
t
t
4. a, b et c sont les entres, s et t les

e
sorties.
a
b
c
a b c
7. a, b et c sont les entres, s la sortie.

e
5. a, b et c sont les entres et s la sortie.

e
s
a b c
a b c

8. a, b et c sont les entres, s0 ,s1 . . .s7

e
les sorties.
s7
s6
s5
s4
s3
s2
s1
s0
a b c
69
70
TD 2.30 : Alternative simple et test simple

Montrer ` laide dun contre-exemple que lalternative simple de la gure 2.10 page 48 nest pas
a
quivalente ` la squence de tests simples suivante :
e
a
e
if not condition : blocElse
TD 2.31 : Racines du trinome
Ecrire un algorithme qui calcule les racines x1 et x2 du trinome ax2 + bx + c.
TD 2.32 : Sequences de tests

1. Quelle est la valeur de la variable x apr`s la suite dinstructions suivante ?
e
x = -3
if x < 0 : x = -x
2. Quelle est la valeur de la variable y apr`s la suite dinstructions suivante ?

e
x0 = 3
x = 5
if x < x0 : y = -1
else : y = 1

e
p = 1
d = 0
r = 0
h = 1
z = 0
f = p and (d or r)
g = not r
m = not p and not z
g = g and (d or h or m)
if f or g : y = 1
else : y = 0
4. Quelle est la valeur de la variable ok apr`s la suite dinstructions suivante ?

e
x = 2
y = 3

71
d = 5
h = 4
if x > 0 and x < d :
if y > 0 and y < h : ok = 1
else : ok = 0
else : ok = 0

e
x = 3
y = -2
if x < y : y = y - x
elif x == y : y = 0
else : y = x - y
`
TD 2.33 : Racine carree entiere
Ecrire un algorithme qui calcule la racine carre enti`re r dun nombre entier positif n telle que
e
e
2 n < (r + 1)2 .
r
TD 2.34 : Executions dinstructions iteratives

1. Que fait cette suite dinstructions ?
x = 0
while x != 33 :
x = input(entrer un nombre : )

x = 0
while x <= 0 or x > 5 :

s = 0
for i in range(5) :
s = s + x
4. Quachent
vantes ?
les
itrations
e
sui-
for i in range(0,10) :
for j in range(0,i) :
print(*,end= )
print()
5. Quachent
vantes ?
les
itrations
e
j = 10 - i
while j > 0 :
print(*,end= )
j = j - 1
print()
sui-
72
6. Quachent
vantes ?
les
itrations
e
sui-
les
itrations
e
sui-
for n in range(0,15) :
for j in range(0,11) :
f = 1
print(i, x, j, = , i*j)
f1 = 1
print()
7. Quachent
vantes ?
8. Quachent
vantes ?
f2 = 1
les
itrations
e
for n in range(10) :
for p in range(n+1) :
num = 1
den = 1
for i in range(1,p+1) :
sui-
f = f1 + f2
f2 = f1
f1 = f
print(f,end= )
9. Quelle est la valeur de la variable s

a
` la n des instructions suivantes ?
num = num*(n-i+1)
b = 2
den = den*i
k = 8
c = num/den
n = 23
print(c,end= )
s = 0
print()
i = k - 1
q = n
while q != 0 and i >= 0 :
s = s + (q%b)*b**(k-1-i)
print(q%b,end= )
q = q/b
i = i - 1
2.5.3
Appliquer

TD 2.35 : Figures geometriques
1. Ecrire un algorithme qui calcule le prim`tre p et la surface s dun rectangle de longueur
e
e
L et de largeur l.
2. Ecrire un algorithme qui calcule le prim`tre p et la surface s dun cercle de rayon r.
e
e
3. Ecrire un algorithme qui calcule la surface latrale s et le volume v dun cylindre de rayon
e
r et de hauteur h.

73
4. Ecrire un algorithme qui calcule la surface s et le volume v dune sph`re de rayon r.

e
TD 2.36 : Suites numeriques

1. Ecrire un algorithme qui calcule la somme s =
arithmtique uk = a + bk.
e
2. Ecrire un algorithme qui calcule la somme s =
gomtrique uk = abk .
e e
n
0 uk
des n premiers termes dune suite
n
0 uk
des n premiers termes dune suite
TD 2.37 : Calcul vectoriel

1. Ecrire un algorithme qui calcule le module r et les cosinus directeurs a, b et c dun vecteur
de composantes (x, y, z).
2. Ecrire un algorithme qui calcule le produit scalaire p de 2 vecteurs de composantes respectives (x1 , y1 , z1 ) et (x2 , y2 , z2 ).
3. Ecrire un algorithme qui calcule les composantes (x3 , y3 , z3 ) du produit vectoriel de 2
vecteurs de composantes respectives (x1 , y1 , z1 ) et (x2 , y2 , z2 ).
4. Ecrire un algorithme qui calcule le produit mixte v de 3 vecteurs de composantes respectives (x1 , y1 , z1 ), (x2 , y2 , z2 ) et (x3 , y3 , z3 ).
TD 2.38 : Prix dune photocopie
Ecrire un algorithme qui ache le prix de n photocopies sachant que le reprographe facture 0,10
E les dix premi`res photocopies, 0,09 E les vingt suivantes et 0,08 E au-del`.
e
a
TD 2.39 : Calcul des impots

Ecrire un algorithme qui ache si un contribuable dun pays imaginaire est imposable ou non
sachant que :
les hommes de plus de 18 ans paient limpt,
o
les femmes paient limpt si elles ont entre 18 et 35 ans,
o
les autres ne paient pas dimpt.
o
TD 2.40 : Developpements limites

Calculer chaque fonction ci-dessous en fonction de son dveloppement en srie enti`re ( uk ).
e
e
e
Les calculs seront arrts lorsque la valeur absolue du terme uk sera infrieure ` un certain seuil
ee
e
a
s (0 < s < 1).
On nutilisera ni la fonction puissance (xn ) ni la fonction factorielle (n!).
74

n
1. sinh(x)
k=0
n
2. cosh(x)
k=0
n
x2k+1
x3
x5
x2n+1
=x+
+
+ ... +
(2k + 1)!
6
120
(2n + 1)!
x2 x4
x2n
x2k
=1+
+
+ ... +
(2k)!
2
24
(2n)!
(1)k
3. cos(x)
k=0
x2 x4
x2n
x2k
=1
+
+ . . . + (1)n
(2k)!
2
24
(2n)!
(1)k
4. log(1 + x)
k=0
n
(1)k
5. arctan(x)
k=0
xk+1
x2 x3
xn+1
=x
+
+ . . . + (1)n
, pour 1 < x < 1
k+1
2
3
n+1
x2k+1
x3 x5
x2n+1
=x
+
+ . . . + (1)n
, pour 1 < x < 1
(2k + 1)
3
5
(2n + 1)
TD 2.41 : Tables de verite

A laide ditrations imbriques, acher les tables de vrit des circuits logiques du TD 2.29
e
e
e e
page 67.
2.5.4
Analyser

TD 2.42 : Dessins geometriques
1. Que dessine la suite dinstructions
suivante ?
2. Que dessine la suite dinstructions

suivante ?
forward(20)
forward(10)
right(144)
left(45)
forward(20)
forward(10)
right(144)
left(135)
forward(20)
forward(10)
right(144)
left(45)
forward(20)
forward(10)
right(144)
left(135)
forward(20)
right(144)

75
TD 2.43 : Police dassurance

Une compagnie dassurance automobile propose 4 familles de tarifs du moins cher au plus
onreux : A, B, C et D. Le tarif dpend de la situation du conducteur.
e
e
Un conducteur de moins de 25 ans et titulaire du permis depuis moins de deux ans, se voit
attribuer le tarif D sil na jamais t responsable daccident. Sinon, la compagnie refuse
ee
de lassurer.
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 C sil
na jamais provoqu daccident, au tarif D pour un accident, sinon il est refus.
e
e
Un conducteur de plus de 25 ans titulaire du permis depuis plus de deux ans bncie du
e e
tarif B sil nest ` lorigine daucun accident et du tarif C pour un accident, du tarif D
a
pour deux accidents, et refus sinon.
e
Par ailleurs, pour encourager la dlit de ses clients, la compagnie propose un contrat au tarif
e e
immdiatement infrieur sil est assur depuis plus dun an.
e
e
e
Ecrire un algorithme qui propose un tarif dassurance selon les caractristiques dun client
e
potentiel.
TD 2.44 : Zero dune fonction

On recherche le zro dune fonction f continue sur un intervalle [a, b] telle que f (a).f (b) < 0 ; il
e
existe donc une racine de f dans ]a, b[ que nous supposerons unique.
1. Ecrire un algorithme qui dtermine le zro de cos(x) dans [1, 2] selon la mthode par
e
e
e
dichotomie.
Indications : on pose x1 = a, x2 = b et x = (x1 + x2 )/2. Si f (x1).f (x) < 0, la racine est
dans ]x1 , x[ et on pose x2 = x ; sinon la racine est dans ]x, x2 [ et on pose x1 = x. Puis on
rit`re le procd, la longueur de lintervalle ayant t divise par deux. Lorsque x1 et x2
e e
e e
ee
e
seront susamment proches, on dcidera que la racine est x.
e
2. Ecrire un algorithme qui dtermine le zro de cos(x) dans [1, 2] selon la mthode des
e
e
e
tangentes.
Indications : soit xn une approximation de la racine c recherche : f (c) = f (xn ) +
e
(c xn )f (xn ) ; comme f (c) = 0, on a : c = xn f (xn )/f (xn ). Posons xn+1 = xn
f (xn )/f (xn ) : on peut considrer que xn+1 est une meilleure approximation de c que xn .
e
On recommence le procd avec xn+1 et ainsi de suite jusqu` ce que |xn+1 xn | soit
e e
a
infrieur ` un certain seuil s.
e
a
76

3. Ecrire un algorithme qui dtermine le zro de cos(x) dans [1, 2] selon la mthode des
e
e
e
scantes.
e
Indications : reprendre la mthode des tangentes en eectuant lapproximation suivante :
e
f (xn ) = (f (xn ) f (xn1 ))/(xn xn1 ).
4. Ecrire un algorithme qui dtermine le zro de cos(x) dans [1, 2] selon la mthode des cordes.
e
e
e
Indications : reprendre la mthode par dichotomie en prenant pour x le point dintersection
e
de la corde AB et de laxe des abscisses : x = (x2 f (x1 ) x1 f (x2 ))/(f (x1 ) f (x2 )), cesta
`-dire le point obtenu par la mthode des scantes.
e
e
2.5.5
TD 2.25 : QCM (2).

Les bonnes rponses sont extraites directement de ce document.
e
1c, 2b, 3c, 4a, 5c, 6a, 7d, 8a, 9d, 10d, 11c, 12a, 13b, 14a, 15b.
TD 2.26 : Unit de longueur.
e
1al 9.46 1015 m et 1m 1.06 1016 al
>>> dAL = 1
>>> dM = dAL/(365.25*3600*24*299792458)
>>> dM
1.0570008340246154e-16
>>> dM = 1
>>> dAL = dM*365.25*3600*24*299792458
>>> dAL
9460730472580800.0
TD 2.27 : Permutation circulaire (2).

De mani`re classique, on passe par une variable intermdiaire tmp pour stocker la premi`re
e
e
e
valeur que lon modie.
>>>
>>>
>>>
>>>
tmp
x =
y =
z =
= x
y
z
tmp
En Python, on peut galement directement crire :

e
e
>>> x, y, z = y, z, x
TD 2.28 : Squence daectations (2).

e

77
>>> n,s
(5, 15)
TD 2.29 : Circuits logiques (2).

Pour tester les direntes solutions obtenues, il faudra dnir au pralable les entres de
e
e
e
e
chaque circuit logique. Par exemple : >>> a = 1
# a = True
>>> b = 0
>>> c = 1
# b = False
# c = True
1.
>>> s = (a and not b) or (b and not a)
>>> s = not (not (a and not b)

...
and
...
not (b and not a))
2.
b
a
s
3.
b
a
b
c
>>> s = (a and not b) or (not a and b)

>>> t = (not a) and b
4.
>>> s = (a != (b != c))
>>> t = (b and c) or (a and (b != c))
t
78
5.
>>> s = (a and c) or (b and c) or (a and b)
a b c
6.
>>> u = a and (not b) and c

>>> s = (a and not c) or u
>>> t = (b and c) or u
a b c
7.
a b c
>>> s = not (not (not a and not b and not c)

...
and
...
not (a and not b and not c)
...
and
...
not (a and b and not c))

79
s7
s6
s5
s4
s3
8.
s2
s1
s0
a b c
>>>
>>>
>>>
>>>
>>>
>>>
>>>
>>>
s7
s6
s5
s4
s3
s2
s1
s0
=
=
=
=
=
=
=
=
a and
a and
a and
a and
not a
not a
not a
not a
b and c
b and not
not b and
not b and
and b and
and b and
and not b
and not b
c
c
not
c
not
and
and
c
c
c
not c
80
TD 2.30 : Alternative simple et test simple.

Il sut que blocIf modie la condition de telle mani`re quelle devienne fausse.
e
>>>
>>>
...
>>>
...
>>>
-1
x = - 1
if x < 0 : x = 3
if x >= 0 : x = -1
print(x)
TD 2.31 : Racines du trinome.

>>>
>>>
...
...
...
...
...
...
...
...
delta = b*b - 4*a*c

if delta > 0 :
x1 = (-b - sqrt(delta))/(2*a)
x2 = (-b + sqrt(delta))/(2*a)
n = 2
elif delta == 0 :
x1 = x2 = -b/(2*a)
n = 1
else : n = 0
TD 2.32 : Squences de tests.

e
1. >>> x
3
2. >>> y
1
3. >>> y
1
4. >>> ok
1
5. >>> y
5
TD 2.33 : Racine carre enti`re.

e
e
>>> n = 8
>>> r = 0
>>> while (r+1)**2 <= n :
...
r = r + 1
...
>>>
>>>
...
...
>>>
3
x = -1
if x < 0 : x = 3
else: x = -1
print(x)

81
TD 2.34 : Excutions dinstructions itratives.

e
e
1. Lalgorithme demande dentrer un
nombre au clavier tant que ce nombre
nest pas gal ` 33
e
a
...
entrer
entrer
entrer
entrer
entrer
>>>
un
un
un
un
un
nombre
nombre
nombre
nombre
nombre
:
:
:
:
:
2
0
fin
3.14
33
2. Lalgorithme demande dentrer un

nombre au clavier tant que ce nombre
nappartient pas ` lintervalle ]0; 5].
a
...
entrer un nombre : 0
entrer un nombre : 6
entrer un nombre : 3.14
>>>
3. Lalgorithme calcule la somme des 5

nombres entrs au clavier.
e
...
entrer
entrer
entrer
entrer
entrer
>>> s
15
un
un
un
un
un
nombre
nombre
nombre
nombre
nombre
:
:
:
:
:
1
3
2
3
6
4. Lalgorithme ache des toiles (*) see

lon la disposition suivante :
...
*
* *
* *
* *
* *
* *
* *
* *
* *
>>>
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
* *
* * *
* * * *
5. Lalgorithme ache des toiles (*) see

lon la disposition suivante :
...
* *
* *
* *
* *
* *
* *
* *
* *
* *
*
>>>
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
* * * *
* * *
* *
*
82
6. Lalgorithme ache les tables de multiplication de 0 ` 9.

a
...
1 x
1 x
1 x
1 x
1 x
1 x
1 x
1 x
1 x
1 x
1 x
0
1
2
3
4
5
6
7
8
9
10
=
=
=
=
=
=
=
=
=
=
2
2
2
2
2
2
2
2
2
2
2
0
1
2
3
4
5
6
7
8
9
10
=
=
=
=
=
=
=
=
=
=
3 x 0
3 x 1
3 x 2
3 x 3
3 x 4
3 x 5
3 x 6
etc...
=
=
=
=
=
=
=
x
x
x
x
x
x
x
x
x
x
x
0
1
2
3
4
5
6
7
8
9
=
10
0
2
4
6
8
10
12
14
16
18
= 20
0
3
6
9
12
15
18
7. Lalgorithme ache le triangle de Pascal jusqu` lordre n = 9.

a
Il sagit des coecients du binme (x +
o
n
n!
y)n =
xnp y p
p!(n p)!
...
1
1 1
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
>>>
p=0
1
3 1
6 4 1
10 10
15 20
21 35
28 56
36 84
5 1
15 6 1
35 21 7 1
70 56 28 8 1
126 126 84 36 9 1
8. Lalgorithme ache les 15 premiers

nombres de la suite de Fibonacci : u0 =
1, u1 = 1, un = un1 + un2 .
...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610
>>>
9. Lalgorithme ache les chires de la

reprsentation de n sur k bits maxie
mum en base b (du plus petit chire
au plus grand). Apr`s excution, la vae
e
leur de s est simplement celle de n : on
vrie ainsi que la conversion en base b
e
est correcte. Dans lexemple (n = 23,
b = 2 et k = 8), la valeur de s est
120 +121 +122 +023 +124 = 23 = n.
...
1 1 1 0 1
>>> s
23

83
TD 2.35 : Figures gomtriques.

e e
1. Prim`tre p et surface s dun rectangle de longueur L et de largeur l
e
e
>>> p = 2*(L+l)
>>> s = L*l
2. Prim`tre p et surface s dun cercle de rayon r

e
e
>>> p = 2*pi*r
>>> s = pi*r*r
3. Surface latrale s et volume v dun cylindre de rayon r et de hauteur h

e
>>> s = 2*pi*r*h
>>> v = pi*r*r*h
4. Surface s et volume v dune sph`re de rayon r

e
>>> s = 4*pi*r*r
>>> v = 4*pi*r*r*r/3
# v = 4*pi*r**3/3
TD 2.36 : Suites numriques.

e
1. Somme s = n uk des n premiers termes dune suite arithmtique uk = a + r k
e
0
n
s=
(a + bk) = a(n + 1) + b
k=0
k = (1 + 2 + 3 + + n) =
avec S =
k
k=1
k=1
n(n + 1)
2
S =
1
+
2
+
3
+ +
n
S =
n
+ n 1 + n 2 + +
1
2S = (n + 1) + (n + 1) + (n + 1) + + (n + 1) = n(n + 1)
Version constante :
>>> s = a*(n+1) + b*n*(n+1)/2
2. Somme s =
n
0 uk
Version itrative :
e
>>> s = 0
>>> for i in range(n+1) :
...
s = s + a + b*i
...
des n premiers termes dune suite gomtrique uk = a bk

e e
n
abk = a
s=
k=0
bk
k=0
84

o` lexpression N = (b0 +b1 +b2 + +bn ) peut tre vue comme le nombre (111 1)b
u
e
en base b. Or en base b, le nombre (b 1)(b0 + b1 + b2 + + bn ) est le nombre
immdiatement infrieur ` bn+1 , soit (b 1)N = bn+1 1.
e
e
a
Exemple en base b = 10 : 99910 = 9(100 + 101 + 102 ) = 103 1
n
bk = (b0 + b1 + b2 + + bn ) =
S=
k=0
Version constante :
>>> s = a*(b**(n+1) - 1)/(b-1)
bn+1 1
b1
Version itrative :
e
>>> s = 0
>>> for i in range(n+1) :
...
s = s + a*b**i
...
TD 2.37 : Calcul vectoriel.

1. Module r et cosinus directeurs a, b et c dun vecteur de composantes (x, y, z)
>>>
>>>
>>>
>>>
r = sqrt(x*x + y*y + z*z)

a1 = x/r
a2 = y/r
a3 = z/r
2. Le produit scalaire p = a b de 2 vecteurs a et b est dni par p =

e
ai bi .
i
>>> p = x1*x2 + y1*y2 + z1*z2
3. Le produit vectoriel c = a b de 2 vecteurs a et b est un vecteur perpendiculaire au

plan du paralllogramme dni par a et b et dont la longueur est gale ` la surface
e
e
e
a
de ce paralllogramme.
e
>>> x3 = y1*z2 - z1*y2
>>> y3 = z1*x2 - x1*z2
>>> z3 = x1*y2 - y1*x2
4. Le produit mixte v = (a b) c de 3 vecteurs a, b et c reprsente le volume du

e
paralllpip`de construit sur ces 3 vecteurs.
ee e
>>> v = (y1*z2 - z1*y2)*x3 + (z1*x2 - x1*z2)*y3 + (x1*y2 - y1*x2)*z3
TD 2.38 : Prix dune photocopie.

>>> if n > 30 : s = 10*0.1 + 20*0.09 + (n-30)*0.08
... elif n > 10 : s = 10*0.1 + (n - 10)*0.09
... else : s = n*0.1
...

85
TD 2.39 : Calcul des impts.

o
>>> if a >
...
if s
...
elif
...
else
... else :
...
18 :
== m : print(imp^t)
o
a < 35 : print(imp^t)
o
: print("pas dimp^t")
o
print("pas dimp^t")
o
TD 2.40 : Dveloppements limits.

e
e
Pour chacun des algorithmes proposs, on pourra vrier la valeur obtenue avec celle de
e
e
la fonction correspondante dans le module math de Python.
>>> from math import *
n
1. y = sinh(x)
k=0
avec uk+1 =
>>>
>>>
>>>
>>>
>>>
...
...
...
...
x2k+1
x3
x5
x2n+1
=x+
+
+ ... +
(2k + 1)!
6
120
(2n + 1)!
x2(k+1)+1
x2
x2k+1
x2
=
=
uk
(2(k + 1) + 1)!
(2k + 2)(2k + 3) (2k + 1)!
(2k + 2)(2k + 3)
k = 0
u = x
y = u
s = 1.e-6
while fabs(u) > s :
u = u*x*x/((2*k+2)*(2*k+3))
y = y + u
k = k + 1
n
2. y = cosh(x)
k=0
x2k
x2 x4
x2n
=1+
+
+ ... +
(2k)!
2
24
(2n)!
avec uk+1 =
>>>
>>>
>>>
>>>
>>>
...
...
...
...
x2(k+1)
x2
x2k
x2
=
=
uk
(2(k + 1))!
(2k + 1)(2k + 2) (2k)!
(2k + 1)(2k + 2)
k = 0
u = 1.
y = u
s = 1.e-6
while fabs(u) > s :
u = u*x*x/((2*k+1)*(2*k+2))
y = y + u
k = k + 1
86

n
(1)k
3. y = cos(x)
k=0
avec uk+1 = (1)k

>>>
>>>
>>>
>>>
>>>
...
...
...
...
x2k
x2 x4
x2n
=1
+
+ . . . + (1)n
(2k)!
2
24
(2n)!
x2(k+1)
x2
x2k
x2
=
(1)k
=
uk
(2(k + 1))!
(2k + 1)(2k + 2)
(2k)!
(2k + 1)(2k + 2)
k = 0
u = 1.
y = u
s = 1.e-6
while fabs(u) > s :
u = -u*x*x/((2*k+1)*(2*k+2))
y = y + u
k = k + 1
(1)k
4. y = log(1 + x)
k=0
xk+1
x2 x3
xn+1
= x + + . . . + (1)n
, pour 1 < x < 1
k+1
2
3
n+1
avec uk+1 = (1)k
k+1
xk+1
k+1
x(k+1)+1
= x
(1)k
= x
uk
(k + 1) + 1
k+2
k+1
k+2
>>> if fabs(x) < 1 :

...
k = 0
...
u = x
...
y = u
...
s = 1.e-6
...
while fabs(u) > s :
...
u = -u*x*(k+1)/(k+2)
...
y = y + u
...
k = k + 1
...
n
(1)k
5. y = arctan(x)
1 < x < 1
k=0
avec uk+1 = (1)k
x2k+1
x3
x5
x2n+1
= x
+
+ . . . + (1)n
, pour
(2k + 1)
3
5
(2n + 1)
x2(k+1)+1
2k + 1
x2k+1
2k + 1
= x2
(1)k
= x2
uk
(2(k + 1) + 1)
2k + 3
(2k + 1)
2k + 3

87
>>> if fabs(x) < 1 :

...
k = 0
...
u = x
...
y = u
...
s = 1.e-6
...
while fabs(u) > s :
...
u = -u*x*x*(2*k+1)/(2*k+3)
...
y = y + u
...
k = k + 1
...
TD 2.41 : Tables de vrit.

e e
1. >>> for a in [0,1] :
2.
...
...
...
...
...
...
0 0
0 0
0 1
0 1
1 0
1 0
1 1
1 1
>>>
...
...
...
...
...
...
0 0
0 1
1 0
1 1
3. >>> for a in [0,1] :
for b in [0,1] :
for c in [0,1] :
s = (a and not b) or
(b and not a)
print(a, b, c, s)
0 0
1 0
0 1
1 1
0 1
1 1
0 0
1 0
for a in [0,1] :
for b in [0,1] :
s = not (not (a and not b)
and
not (b and not a))
print(a, b, s)
0
1
1
0
4.
...
...
...
...
...
0 0
0 1
1 0
1 1
>>>
...
...
...
...
...
...
for b in [0,1] :
s = (a and not b) or (not a and b)
t = (not a) and b
print(a, b, s, t)
0 0
1 1
1 0
0 0
for a in [0,1] :
for b in [0,1] :
for c in [0,1] :
s = (a != (b != c))
t = (b and c) or (a and (b != c))
print(a, b, c, s, t)
88
5. >>> for a in [0,1] :
6.
...
...
...
...
...
...
...
0 0
0 0
0 1
0 1
1 0
1 0
1 1
1 1
>>>
...
...
...
...
...
...
...
...
...
0 0
0 0
0 1
0 1
1 0
1 0
1 1
1 1
7. >>> for a in [0,1] :
for b in [0,1] :
for c in [0,1] :
s = not (not (a and b) and
not (a and c) and
not (b and c))
print(a, b, c, s)
...
...
...
...
...
...
...
0 0
0 0
1 0
0 0
0 0
0 1
1 1
0 1
0 0
1 0
1 1
1 0
0 1
1 1
1 1
1 1
for a in [0,1] :
8. >>>
for b in [0,1] :
...
for c in [0,1] :
...
s = not (not (not a and
...
not b and not c) and ...
not (a and not b and
...
not c) and
...
not (a and b and not c))
...
print(a, b, c, s)
...
...
0 1
...
1 0
...
0 0
...
1 0
0 0
0 1
0 0
1 0
0 1
0 1
0 1
1 0
1 0
1 0
1 1
1 1
TD 2.42 : Dessins gomtriques.

e e
1. Une toile ` 5 branches
e
a
for b in [0,1] :
for c in [0,1] :
u = (b and not c) or (not b and c)
s = (a and not u) or (not a and u)
t = (b and c) or (a and u)
print(a, b, c, u, s, t)
0 0 0 0
1 1 1 0
0 1 1 0
1 0 0 1
0 0 1 0
1 1 0 1
0 1 0 1
1 0 1 1
for a in [0,1] :
for b in [0,1] :
for c in [0,1] :
s7 = a and b and c
s6 = a and b and not c
s5 = a and not b and c
s4 = a and not b and not c
s3 = not a and b and c
s2 = not a and b and not c
s1 = not a and not b and c
s0 = not a and not b and not c
print(a, b, c, s0, s1, s2, s3, s4, s5, s6, s7)
0
1
0
1
0
1
0
1
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
1

89
2. Un losange
TD 2.43 : Police dassurance.
Il sagit en fait dune assurance a points (p) qui dpend de lge a du conducteur, de lan`
e
a
ciennet d du permis, du nombre n daccidents et du nombre r dannes en tant quassur
e
e
e
d`le.
e
>>>
>>>
...
>>>
...
>>>
>>>
>>>
...
>>>
...
...
...
...
...
p = 0
if a < 25 : p = p + 1
# jeune
if d < 2 : p = p + 1
# jeune conducteur
p = p + n
# accidents
if p < 3 and r > 1 : p = p - 1
# fidlit
e
e
if p
elif
elif
elif
else
== -1 : print(tarif A)
p == 0 : print(tarif B)
p == 1 : print(tarif C)
p == 2 : print(tarif D)
: print(refus dassurer)
TD 2.44 : Zro dune fonction.

e
1. Mthode par dichotomie
e
>>> x1 = 1.
>>> x2 = 3.
>>> x = (x1 + x2)/2.
>>> s = 1.e-9
>>> f = cos
>>> while (x2 - x1) > s :
...
if f(x1)*f(x) < 0 : x2 = x
...
else : x1 = x
...
x = (x1 + x2)/2.
>>> x, cos(x)
(1.5707963271997869, -4.048902822446996e-10)
2. Mthode des tangentes

e
90

>>> x1 = 1.
>>> x2 = 2.
>>> s = 1.e-9
>>> f = cos
>>> df = sin
>>> x = x2 - f(x2)/(-df(x2))
>>> while fabs(x-x2) > s :
...
x2 = x
...
x = x - f(x)/(-df(x))
...
>>> x, cos(x)
(1.5707963267948966, 6.1230317691118863e-17)
3. Mthode des scantes

e
e
>>> x1 = 1.
>>> x2 = 2.
>>> s = 1.e-9
>>> f = cos
>>> df = (f(x2)-f(x1))/(x2-x1)
>>> x = x2 - f(x2)/df
...
x2 = x
...
df = (f(x2)-f(x1))/(x2-x1)
...
x = x - f(x)/df
...
>>> x, cos(x)
(1.570796326805755, -1.085836403972619e-11)
4. Mthode des cordes

e
>>> x1 = 1.
>>> x2 = 3.
>>> x = (x2*f(x1) - x1*f(x2))/(f(x1)-f(x2))
>>> s = 1.e-9
>>> f = cos
>>> while (x2-x1) > s :
...
if f(x1)*f(x) < 0 : x2 = x
...
else : x1 = x
...
x = (x2*f(x1) - x1*f(x2))/(f(x1)-f(x2))
...
>>> x, cos(x)
(1.5707963267948966, 6.1230317691118863e-17)
2.6. ANNEXES
2.6
Annexes
2.6.1
Instructions Logo
Logo is the name for a philosophy of education and a continually evolving family of programming languages
that aid in its realization (Harold Abelson, Apple Logo, 1982). This statement sums up two fundamental
aspects of Logo and puts them in the proper order. The Logo programming environments that have been
developed over the past 28 years are rooted in constructivist educational philosophy, and are designed to
support constructive learning. [. . .] Constructivism views knowledge as being created by learners in their
own minds through interaction with other people and the world around them. This theory is most closely
associated with Jean Piaget, the Swiss psychologist, who spent decades studying and documenting the learning
processes of young children.
Logo Foundation : http://el.media.mit.edu/logo-foundation
On suppose connues les procdures de tracs gomtriques ` la Logo :

e
e e e
a
degrees() xe lunit dangle en degrs
e
e
radians() xe lunit dangle en radians
e
reset() eace lcran et rinitialise les variables
e
e
clear() eace lcran
e
up() l`ve le crayon
e
down() abaisse le crayon
forward(d) avance dune distance d
backward(d) recule dune distance d
left(a) tourne sur la gauche dun angle a
right(a) tourne sur la droite dun angle a
goto(x,y) dplace le crayon ` la position (x, y)
e
a
towards(x,y) oriente vers le point de coordonnes (x, y)
e
setheading(a) oriente dun angle a par rapport ` laxe des x
a
position() donne la position (x, y) du crayon
heading() donne lorientation a du dplacement
e
circle(r) trace un cercle de rayon r
circle(r,a) trace un arc de cercle de rayon r et dangle au sommet a.
91
92
2.6.2
Instructions Python
Les principales instructions Python sont listes dans les tableaux ci-dessous, tableaux exe
traits du Python 2.5 Quick Reference Guide [10].
Miscellaneous statements
Statement
pass
del name[, name]*
print([s1 [, s2 ]*)
input([prompt])
Assignment operators
Operator
a = b
a += b
a -= b
a *= b
a /= b
a //= b
a %= b
a **= b
a &= b
a |= b
a ^= b
a >>= b
a <<= b
Result
Null statement
Unbind name(s) from object
Writes to sys.stdout, or to fileobject if supplied. Puts spaces between arguments si. Puts newline at
end unless arguments end with end=
(ie : end= ). print is not required
when running interactively, simply typing an expression will print its value,
unless the value is None.
Prints prompt if given. Reads input
and evaluates it.
Result
Basic assignment - assign object b to label a
a = a + b
a = a - b
a = a * b
a = a / b
a = a // b
to a = a % b
to a = a ** b
a = a & b
a = a | b
a = a ^ b
a = a >> b
a = a << b
2.6. ANNEXES
93
Control ow statements
Statement
if condition :
suite
[elif condition : suite]*
[else :
suite]
while condition :
suite
[else :
suite]
suite
[else :
suite]
break
continue
return [result]
Result
Usual if/else if/else statement.
Usual while statement. The else suite is executed after loop exits, unless the loop is exited
with break.
Iterates over sequence, assigning each element
to element. Use built-in range function to iterate a number of times. The else suite is executed at end unless loop exited with break.
Immediately exits for or while loop.
Immediately does next iteration of for or while
loop.
Exits from function (or method) and returns
result (use a tuple to return more than one
value).
Name space statements

Imported module les must be located in a directory listed in the path (sys.path).
Packages : a package is a name space which maps to a directory including module(s) and
the special initialization module init .py (possibly empty).
Packages/directories can be nested. You address a modules symbol via
[package.[package...].module.symbol .
94
Statement
import module1 [as name1] [,
module2]*
from module import name1 [as

othername1][, name2]*
from module import *
Result
Imports modules. Members of module
must be referred to by qualifying with
[package.]module name, e.g. :
import sys ; print(sys.argv)
import package1.subpackage.module
package1.subpackage.module.foo()
module1 renamed as name1, if supplied.
Imports names from module module in current
namespace, e.g. :
from sys import argv ; print(argv)
from package1 import module ;
module.foo()
from package1.module import foo ;
foo()
name1 renamed as othername1, if supplied.
Imports all names in module, except those starting with .
2.6. ANNEXES
2.6.3
95
Construction dune boucle
Un algorithme est un mcanisme qui fait passer un syst`me dune situation dite
e
e
initiale (ou prcondition) ` une situation nale (postcondition ou but). Le couple (situation
e
a
initiale, situation nale) est appel spcication de lalgorithme. Lalgorithmique vise donc `
e e
a
construire rationnellement des algorithmes ` partir de leur spcication.
a
e
Exemple 2.20 : Enfoncer un clou
On dispose dune planche, dun marteau et dun clou (situation initiale) et on veut que le clou
soit enfonc dans la planche jusqu` la tte (situation nale).
e
a
e
Le travail ` raliser consiste donc ` planter lg`rement le clou ` la main de faon quil tienne
a e
a
e e
a
c
seul, puis ` taper sur la tte du clou avec le marteau tant que la tte ne touche pas la planche.
a
e
e
Le nombre de coups ncessaire est a priori inconnu.
e
Le raisonnement qui permet de passer dune comprhension intuitive dun tel nonc ` lale
e
e a
gorithme nest pas toujours facile ` concevoir dun coup. Dans le cas dune boucle on pourra
a
systmatiser la conception de lalgorithme autour de 4 tapes (dapr`s [7] et [11]) :
e
e
e
1. Invariant (ou hypoth`se de rcurrence) : Le clou est plant dans la planche .
e
e
e
2. Condition darrt : La tte touche la planche .
e
e
3. Progression : Frapper un coup de marteau de faon ` enfoncer un peu plus le clou .
c a
4. Initialisation : Planter lg`rement le clou ` la main .
e e
a
Il faut noter que les tapes 1 et 2 dnissent des situations tandis que les tapes 3 et 4 concernent
e
e
e
des actions. Dans cette section, on notera les situations entre crochets ([]) pour les distinguer
des actions.
La recherche dun invariant est ltape cl autour de laquelle sarticule la conception des
e
e
boucles. La conjonction de linvariant et de la condition darrt conduit logiquement au
e
but recherch :
e
[ invariant and condition darr^t ] [ postcondition ]
e
La condition darrt seule nimplique pas le but : un clou pos sur la planche la pointe en
e
e
lair a bien la tte qui touche la planche, mais il nest pas plant dans la planche.
e
e
96

La progression doit :
conserver linvariant (pas de coup de marteau qui dplanterait le clou !). Plus prcisment,
e
e e
la progression est un fragment dalgorithme dni par les situations initiale et nale suie
vantes :
situation initiale : [ invariant and not condition darr^t ]
e
situation nale : [ invariant ]
Dans lexemple du clou, tant donne la prcondition [ le clou est plant dans
e
e
e
e
la planche and la t^te ne touche pas la planche ], et la postcondition [
e
le clou est enfonc dans la planche ], une solution ` la progression est frape
a
per un coup de marteau .
[ invariant and not condition darr^t ]
e
progression
[ invariant ]
faire eectivement progresser vers le but pour faire en sorte que la condition darrt soit
e
atteinte au bout dun temps ni. Ici il est ncessaire de faire dcro
e
e tre la hauteur du
clou au dessus de la planche.
Linitialisation doit instaurer linvariant. Plus prcisment, elle doit, partant de la prcondie e
e
tion, atteindre linvariant.
[ prcondition ]
e
initialisation
[ invariant ]
Pour enfoncer un clou dans une planche, on excutera ainsi lalgorithme suivant :
e
[ on dispose dune planche dun marteau, dun clou ]
Planter lg`rement le clou ` la main
e e
a
[ le clou est plant dans la planche ]
e
while [ la t^te du clou ne touche pas la planche ] :
e
frapper un coup de marteau sur la t^te du clou
e
[ le clou est plant dans la planche ]
e
[ le clou est enfonc dans la planche ]
e
2.6. ANNEXES
97
Dune mani`re plus gnrale, les 4 tapes de construction dune boucle sont les suivantes :
e
e e
e
1. Invariant : proposer une situation gnrale dcrivant le probl`me pos (hypoth`se de
e e
e
e
e
e
rcurrence). Cest cette tape qui est la plus dlicate car elle exige de faire preuve dimae
e
e
gination.
Exemple de la puissance 2.11 :
Exemple du pgcd 2.13 :
k+1 = x xk
x
pgcd(a, b) = pgcd(b, a mod b)
2. Condition darrt : ` partir de la situation gnrale imagine en [1], on doit formuler la
e a
e e
e
condition qui permet darmer que lalgorithme a termin son travail. La situation dans
e
laquelle il se trouve alors est appele situation nale. La condition darrt fait sortir de la
e
e
boucle.
k > n
b == 0
3. Progression : se rapprocher de la situation nale, tout en faisant le ncessaire pour
e
conserver ` chaque tape une situation gnrale analogue ` celle retenue en [1]. La proa
e
e e
a
gression conserve linvariant.
p = p*x
r = a%b
k = k + 1
a = b
b = r
4. Initialisation : initialiser les variables introduites dans linvariant pour que celui-ci soit
vri avant dentrer dans la boucle. Linitialisation instaure linvariant.
e e
k = 1
p = x
5. Boucle nale : Une fois les 4 tapes prcdentes menes ` leur terme, lalgorithme ree
e e
e a
cherch aura la structure nale suivante (gure 2.20) :
e
TD2.45
[ prcondition ]
e
initialisation
[ invariant ]
while not [ condition darr^t ] :
e
progression
[ invariant ]
[ postcondition ]
Fig. 2.20 : Invariant de boucle

[invariant]
initialisation
[invariant]
[not condition darrt]
progression
[condition darrt]
Dans la pratique, on ne teste pas les invariants.
initialisation
[not condition darrt]
progression
[condition darrt]

Reprendre le TD 2.19 page 58 en explicitant linvariant,
la condition darrt, la progression et linitialisation de la
e
boucle retenue.
98

Quand on sort de la boucle, la situation nale attendue est atteinte.
Dans la pratique, on ne garde que les instructions :
initialisation
while [not condition darr^t ] :
e
progression
k = 1
while not b == 0 :
p = x
r = a%b
while not k > n :
a = b
p = p*x
b = r
k = k + 1
Un des probl`mes, pour lapprenti informaticien, est que la boucle nale ainsi obtenue ne
e
fait pas appara explicitement linvariant dans le code. Linvariant est une aide conceptre
tuelle pour construire la boucle, mais pas pour lexcuter.
e
Dnition 2.8 :
e
Un invariant de boucle est une proprit vrie tout au long de lexcution de la boucle.
ee e e
e
Cette faon de procder permet de prouver la validit de lalgorithme au fur et ` mesure de
c
e
e
a
son laboration. En eet la situation gnrale choisie en [1] est en fait linvariant qui caractrise
e
e e
e
la boucle while. Cette situation est satisfaite au dpart grce ` linitialisation de ltape [4] ;
e
a a
e
elle reste vraie ` chaque itration (tape [3]). Ainsi lorsque la condition darrt (tape [2]) est
a
e
e
e e
atteinte cette situation nous permet darmer que le probl`me est rsolu. Cest galement en
e
e
e
analysant ltape [3] quon peut prouver la terminaison de lalgorithme.
e
Chapitre 3
Procdures et fonctions
e
Sommaire
3.1
Informatique
S1
Informatique
a
e
2. Appel dune fonction
Jacques TISSEAU
Jacques TISSEAU
3.2
a
e
1. Dnition dune fonction
e
S1
3.3
o
o
enib c 2009
enib c 2009
3.4
tisseau@enib.fr
Algorithmique
enib c 2009
1/21
tisseau@enib.fr
Algorithmique
enib c 2009
1/14
3.5
99
Introduction . . . . . . . . . . . . . .
3.1.1 Rutiliser . . . . . . . . . . . .
e
3.1.2 Structurer . . . . . . . . . . .
3.1.3 Encapsuler . . . . . . . . . . .
Dnition dune fonction . . . . . . .
e
3.2.1 Nommer . . . . . . . . . . . .
3.2.2 Paramtrer . . . . . . . . . . .
e
3.2.3 Protger . . . . . . . . . . . .
e
3.2.4 Tester . . . . . . . . . . . . . .
3.2.5 Dcrire . . . . . . . . . . . . .
e
3.2.6 Encapsuler . . . . . . . . . . .
3.2.7 Conclure . . . . . . . . . . . .
Appel dune fonction . . . . . . . . .
3.3.1 Passage des param`tres . . .
e
3.3.2 Param`tres par dfaut . . . .
e
e
3.3.3 Porte des variables . . . . .
e
3.3.4 Appels rcursifs . . . . . . . .
e
Exercices complmentaires . . . . . .
e
3.4.1 Conna
tre . . . . . . . . . . . .
3.4.2 Comprendre . . . . . . . . . .
3.4.3 Appliquer . . . . . . . . . . . .
3.4.4 Analyser . . . . . . . . . . . .
3.4.5 Solutions des exercices . . . .
Annexes . . . . . . . . . . . . . . . . .
3.5.1 Instructions Logo . . . . . . .
3.5.2 Fonctions Python prdnies
e e
3.5.3 Fonctions en Python . . . . .
3.5.4 Lutilitaire pydoc . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
100
100
101
102
104
105
106
107
108
110
112
114
115
115
119
120
121
128
128
130
131
132
137
152
152
153
155
156

CHAPITRE 3. PROCEDURES ET FONCTIONS
100
3.1
Introduction
3.1.1
Remarque 3.1 : Les chires ri en base b sont tels que
0 ri < b.
Exemples :
b = 2 : ri {0, 1} (bit = binary digit)
Rutiliser
e
Exemple 3.1 : Numeration en base b

Un entier positif en base b est reprsent par une suite de chires (rn rn1 . . . r1 r0 )b o` les ri
e
e
u
sont des chires de la base b (0 ri < b). Ce nombre a pour valeur :
b = 10 : ri {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
i=n
rn bn + rn1 bn1 + . . . + r1 b1 + r0 b0 =
b = 16 : ri {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f }
Plus la base b est faible plus il faut de chires pour
reprsenter un mme nombre.
e
e
Exemples :
(128)10 = 1.102 + 2.101 + 8.100 =
(128)10
= 1.27
= (10000000)2
= 8.161
=
(80)16
TD 3.1 : Codage des entiers positifs (1)
Dnir un algorithme qui code sur k chires en base b un
e
entier positif n du syst`me dcimal.
e
e
Exemples : (38)10 (123)5
(83)10 (123)8
(291)10 (123)16
ri bi
i=0
Exemples : (123)10
(123)5
(123)8
(123)16
=
=
=
=
1.102 + 2.101 + 3.100

1.52 + 2.51 + 3.50
1.82 + 2.81 + 3.80
1.162 + 2.161 + 3.160
= (123)10
= (38)10
= (83)10
= (291)10
On suppose que le nombre n est reprsent par un tableau de chires (code) en base b ; par
e
e
exemple si b = 5 et code = [1,2,3], alors en base 10 le nombre entier n correspondant vaudra
38 (1 52 + 2 51 + 3 50 = 25 + 10 + 3 = 38). Etant donns code et b, lalgorithme suivant permet
e
de calculer n en base 10 :
n = 0
for i in range(len(code)):
n = n + code[i]*b**(len(code)-1-i)
On ajoute successivement les puissances de la base

ri bi (code[i]*b**(len(code)-1-i)).
TD3.1
Fig. 3.1 : Reutilisabilite dun algorithme

La rutilisabilit dun algorithme est son aptitude `
e
e
a
tre rutilis pour rsoudre des tches quivalentes
e
e
e
e
a
e
a
` celle pour laquelle il a t conu.
ee
c
Sous linterprteur Python, pour calculer successivement la valeur dcimale n des nombres
e
e
(123)5 et (123)8 , nous devrons donc recopier 2 fois lalgorithme ci-dessus.
>>>
>>>
>>>
>>>
...
...
>>>
38
b = 5
code = [1,2,3]
n = 0
n
>>>
>>>
>>>
>>>
...
...
>>>
83
b = 8
code = [1,2,3]
n = 0
n
Dans la pratique, on ne souhaite pas recopier 2 fois le mme code dautant plus si celui-ci ncessite
e
e
de tr`s nombreuses lignes de code. Pour amliorer la rutilisabilit de lalgorithme (gure 3.1)
e
e
e
e
autrement que par un copier-coller , une solution sera lencapsulation du code ` rpter au
a e e
3.1. INTRODUCTION
101
sein dune fonction (gure 3.2) comme on en a lhabitude avec les fonctions mathmatiques
e
classiques : on appelle la fonction sinus (sin(x)) plutt que la rednir ` chaque fois ! Ainsi, il
o
e
a
arrivera souvent quune mme squence dinstructions doive tre utilise ` plusieurs reprises dans
e
e
e
e a
un algorithme, et on souhaitera bien videmment ne pas avoir ` la reproduire systmatiquement.
e
a
e
Pour cela, le concepteur dnira et utilisera ses propres fonctions qui viendront complter
e
e
le jeu dinstructions initial.
3.1.2
Structurer
Fig. 3.2 : Encapsulation

Lencapsulation est laction de mettre une chose
dans une autre : on peut considrer que cette chose
e
est mise dans une capsule comme on conditionne
un mdicament dans une enveloppe soluble (la cape
sule). Ici, il sagit dencapsuler des instructions dans
une fonction ou une procdure.
e
Exemple 3.2 : Nombres fractionnaires

Un nombre fractionnaire (nombre avec des chires apr`s la virgule : (rn rn1 . . . r1 r0 .r1 r2 . . .)b )
e
est dni sur un sous-ensemble born, incomplet et ni des rationnels. Un tel nombre a pour
e
e
valeur :
rn bn + rn1 bn1 + . . . + r1 b1 + r0 b0 + r1 b1 + r2 b2 + . . .
En pratique, le nombre de chires apr`s la virgule est limit par la taille physique en machine.
e
e
i=n
ri bi
(rn rn1 . . . r1 r0 .r1 r2 . . . rk )b =

i=k
Un nombre x pourra tre reprsent en base b par un triplet [s, m, p] tel que x = (1)s m bp
e
e
e
o` s reprsente le signe de x, m sa mantisse et p son exposant (p comme puissance) o` :
u
e
u
signe s : s = 1 si x < 0 et s = 0 si x 0
mantisse m : m [1, b[ si x = 0 et m = 0 si x = 0
exposant p : p [min, max]
TD 3.2 : Codage dun nombre fractionnaire
Dterminer le signe, la mantisse et lexposant binaires
e
du nombre fractionnaire x = 140.8125 en suivant les 4
tapes dcrites ci-contre.
e
e
Ainsi, le codage de x = 9.75 en base b = 2 seectuera en 4 tapes :

e
1. coder le signe de x : x = 9.75 < 0 s = 1
2. coder la partie enti`re de |x| : 9 = (1001)2
e
3. coder la partie fractionnaire de |x| : 0.75 = (0.11)2
4. et coder |x| en notation scientique normalise : m [1, 2[
e
(1001)2 + (0.11)2 = (1001.11)2 = (1.00111)2 23
= (1.00111)2 2(11)2
TD3.2

102
Fig. 3.3 : Module math de Python

Constante
pi
e
Fonction
acos(x)
asin(x)
atan(x)
atan2(y,x)
ceil(x)
cos(x)
cosh(x)
degrees(x)
exp(x)
fabs(x)
floor(x)
frexp(x)
hypot(x,y)
ldexp(x,i)
log(x[,b=e])
log10(x)
modf(x)
pow(x,y)
radians(x)
sin(x)
sinh(x)
sqrt(x)
tan(x)
tanh(x)
Valeur
3.1415926535897931
2.7182818284590451
Rsultat
e
arc cosinus (en radians).
arc sinus (en radians).
arc tangente (en radians).
arc tangente (en radians) de y/x.
le plus petit entier >= x.
cosinus (en radians).
cosinus hyperbolique.
conversion radians degrs.
e
exponentielle.
valeur absolue.
le plus grand entier <= x.
mantisse m and exposant p de x
x = m * 2.**p.
distance euclidienne
sqrt(x*x + y*y).
x * (2**i).
logarithme en base b.
logarithme en base 10.
parties fractionnaire et enti`re de
e
x.
x puissance y (x**y).
conversion degrs radians.
e
sinus (en radians).
sinus hyperbolique.
racine carre.
e
tangente (en radians).
tangente hyperbolique.
Cette dmarche conduit au rsultat x = (1)1 (1.00111)2 2(11)2 o` s = (1)2 , m = (1.00111)2

e
e
u
et p = (11)2 .
Lapproche ecace dun probl`me complexe (coder un nombre fractionnaire) consiste soue
vent ` le dcomposer en plusieurs sous-probl`mes plus simples (coder le signe, coder la mantisse,
a
e
e
coder lexposant) qui seront tudis sparment. Ces sous-probl`mes peuvent ventuellement
e
e e e
e
e
tre eux-mmes dcomposs ` leur tour (coder la partie enti`re, coder la partie fractionnaire,
e
e
e
e a
e
normaliser), et ainsi de suite. L` encore, le concepteur dnira et utilisera ses propres fonca
e
tions pour raliser la structuration dun probl`me en sous-probl`mes : il divise le probl`me en
e
e
e
e
sous-probl`mes pour mieux le contrler (diviser pour rgner).
e
o
e
3.1.3
Encapsuler
Exemple 3.3 : Calcul de sin(/2)

>>>
>>>
1.0
>>>
>>>
1.0
from math import sin, pi

sin(pi/2)
y = sin(pi/2)
y
Cette petite session Python illustre quelques caractristiques importantes des fonctions.
e
Une fonction ` un nom : sin.
a
Une fonction est en gnral range dans une biblioth`que de fonctions (ici la biblioth`e e
e
e
e
que math de Python, gure 3.3) ; il faut aller la chercher (on importe la fonction) :
from math import sin.
Une fonction sutilise (s appelle ) sous la forme dun nom suivi de parenth`ses ; dans
e
les parenth`ses, on transmet ` la fonction un ou plusieurs arguments : sin(pi/2).
e
a
Lvaluation de la fonction fournit une valeur de retour ; on dit aussi que la fonction
e
renvoie ou retourne une valeur (sin(pi/2) 1.0) qui peut ensuite tre aecte
e
e
a
` une variable : y = sin(pi/2).
Dnition 3.1 : fonction
e
Une fonction est un bloc dinstructions nomm et paramtr, ralisant une certaine tche. Elle
e
e e e
a
admet zro, un ou plusieurs param`tres et renvoie toujours un rsultat.
e
e
e
Une fonction en informatique se distingue principalement de la fonction mathmatique par
e
le fait quen plus de calculer un rsultat ` partir de param`tres, la fonction informatique peut
e
a
e
3.1. INTRODUCTION
103
avoir des eets de bord : par exemple acher un message ` lcran, jouer un son, ou bien
a e
piloter une imprimante. Une fonction qui na pas deet de bord joue le rle dune expression
o
valuable. Une fonction qui na que des eets de bord est appele une procdure et joue le rle
e
e
e
o
dune instruction.
Dnition 3.2 : procedure

e
Une procdure est un bloc dinstructions nomm et paramtr, ralisant une certaine tche. Elle
e
e
e e e
a
admet zro, un ou plusieurs param`tres et ne renvoie pas de rsultat.
e
e
e
Les procdures et les fonctions intgres au langage sont relativement peu nombreuses : ce
e
e e
sont seulement celles qui sont susceptibles dtre utilises tr`s frquemment (lannexe 3.5.2 page
e
e
e e
153 prsente les principales fonctions intgres systmatiquement avec linterprteur Python).
e
e e
e
e
Les autres fonctions sont regroupes dans des chiers spars que lon appelle des modules. Les
e
e e
modules sont donc des chiers qui regroupent des ensembles de fonctions. Souvent on regroupe
dans un mme module des ensembles de fonctions apparentes que lon appelle des biblioth`ques.
e
e
e
Pour pouvoir utiliser ces fonctions, il faut importer le module correspondant.
Ainsi en Python, il existe de nombreux modules additionnels dont le plus connu est le
module math qui dnit une vingtaine de constantes et fonctions mathmatiques usuelles (gure
e
e
3.3). On peut importer ce module de direntes mani`res :
e
e
>>> from math import sin, pi
>>> sin(pi/2)
1.0
Fig. 3.4 : Metaphore de la bo de cubes

te
from lego import cube
import lego
>>> import math

>>> math.sin(math.pi/2)
1.0
Pour comprendre la dirence entre ces deux mthodes, aidons-nous de la mtaphore des cubes
e
e
e
a
` la Lego (gure 3.4). Nous disposons dune bo de cubes (lego) range sous la table. Pour
te
e
utiliser un cube de cette bo nous pouvons soit prendre le cube dans la bo et le mettre sur
te,
te
la table (from lego import cube) : le cube est alors directement accessible sur la table (cube) ;
soit mettre la bo sur la table (import lego) : le cube nest alors pas directement accessible,
te
il faut encore le prendre dans la bo (lego.cube). Lintrt de cette deuxi`me mthode est de
te
ee
e
e
distinguer 2 cubes qui porteraient le mme nom (cube) mais qui ne seraient pas originaires de la
e
mme bo (bo lego et duplo) et qui seraient donc dirents (lego.cube et duplo.cube).
e
te
tes
e
Il est possible galement de verser tout le contenu de la bo sur la table (from lego import
e
te
*) : ici, lastrisque (*) signie tout .
e
>>> sqrt(tan(log(pi)))
1.484345173593278
duplo.cube
lego.cube
Remarque 3.2 : Lego est une socit danoise fabriee

quant des jeux dont le produit phare est un jeu de briques
en plastique ` assembler.
a
104
3.2
Dnition dune fonction

e
Pour encapsuler un algorithme dans une fonction, on suivra pas ` pas la dmarche suivante :
a
e
1. donner un nom explicite ` lalgorithme,
a
2. dnir les param`tres dentre-sortie de lalgorithme,
e
e
e
3. prciser les prconditions sur les param`tres dentre,
e
e
e
e
4. donner des exemples dutilisation et les rsultats attendus,
e
5. dcrire par une phrase ce que fait lalgorithme et dans quelles conditions il le fait,
e
6. encapsuler lalgorithme dans la fonction spcie par les 5 points prcdents.
e e
e e
Les 5 premi`res tapes rel`vent de la spcication de lalgorithme et la derni`re tape concerne
e
e
e
e
e e
lencapsulation proprement dite de lalgorithme. En Python, la spcication sera excutable :
e
e
a
` chaque tape, le code de la fonction est toujours excutable mme sil ne donne pas encore
e
e
e
le bon rsultat ; seule la derni`re tape dencapsulation (voir section 3.2.6 page 112) permettra
e
e e
dobtenir le rsultat valide attendu.
e
Dnition 3.3 : specification dun algorithme

e
La spcication dun algorithme dcrit ce que fait lalgorithme et dans quelles conditions il le
e
e
fait.
Dnition 3.4 : implementation dun algorithme

e
Limplmentation dun algorithme dcrit comment fait lalgorithme pour satisfaire sa spcication.
e
e
e
Exemple 3.4 : Nombres de Fibonacci
La fonction de Fibonacci calcule le nombre un ` lordre n (dit de Fibonacci) selon la relation de
a
rcurrence :
e
u0 = 1 , u1 = 1 , un = un1 + un2 n N, n > 1
Les 10 premiers nombres de Fibonacci valent donc : u0 = 1, u1 = 1, u2 = 2, u3 = 3, u4 = 5,
u5 = 8, u6 = 13, u7 = 21, u8 = 34 et u9 = 55.
Dans cette section, nous utiliserons cet exemple comme l conducteur dans la dnition dune
e
e
fonction. Ainsi donc, nous voulons dnir une fonction qui calcule le ni`me nombre de Fibonacci.
e
e
Cette description de la fonction ( calculer le ni`me nombre de Fibonacci ) voluera progrese
sivement ` chaque tape et deviendra susamment prcise pour quun autre utilisateur puisse
a
e
e
lutiliser eectivement sans surprise et en toute scurit.
e
e

3.2. DEFINITION DUNE FONCTION
3.2.1
105
Nommer
La premi`re chose ` faire est de nommer la fonction qui encapsule lalgorithme. Les noms
e
a
de fonction sont des identicateurs arbitraires, de prfrence assez courts mais aussi explicites
ee
que possible, de mani`re ` exprimer clairement ce que la fonction est cense faire. Les noms des
e a
e
fonctions doivent en outre obir ` quelques r`gles simples :
e a
e
Un nom de fonction est une squence de lettres (a. . .z , A. . .Z) et de chires (0. . .9), qui
e
doit toujours commencer par une lettre.
Seules les lettres ordinaires sont autorises. Les lettres accentues, les cdilles, les espaces,
e
e
e
les caract`res spciaux tels que $, #, @, etc. sont interdits, ` lexception du caract`re
e
e
a
e
(soulign).
e
La casse est signicative : les caract`res majuscules et minuscules sont distingus.
e
e
Ainsi, sinus, Sinus, SINUS sont des fonctions direntes.
e
Par convention, on crira lessentiel des noms de fonction en caract`res minuscules (y
e
e
compris la premi`re lettre). On nutilisera les majuscules qu` lintrieur mme du nom
e
a
e
e
pour en augmenter ventuellement la lisibilit, comme dans triRapide ou triFusion.
e
e
Le langage lui-mme peut se rserver quelques noms comme cest le cas pour Python
e
e
(gure 3.5). Ces mots rservs ne peuvent donc pas tre utiliss comme noms de fonction.
e
e
e
e
En ce qui concerne la fonction de Fibonacci de lexemple 3.4, nous choisissons de lappeler
simplement fibonacci. Ce qui se traduira en Python par len-tte suivante o` def et return
e
u
sont deux mots rservs par Python pour dnir les fonctions (voir annexe 3.5.3 page 155) :
e
e
e
def fibonacci():
return
>>> from fibo import fibonacci

>>> fibonacci()
>>>
Le code de la partie gauche est la dnition actuelle de la fonction fibonacci que lon a dite
e
e e
dans un chier fibo.py : le module associ a donc pour nom fibo. La partie droite montre
e
comment on utilise couramment le module fibo et la fonction fibonacci sous linterprteur
e
Python. Dans ltat actuel, cette fonction na pas darguments et ne fait rien ! Mais elle est dj`
e
ea
compilable et excutable. On peut la dcrire de la mani`re suivante : La fonction fibonacci
e
e
e
calcule un nombre de Fibonacci .
Fig. 3.5 : Mots reserves en Python

and
assert
break
class
continue
def
del
elif
else
except
exec
finally
for
from
global
if
import
in
is
lambda
not
or
pass
print
raise
return
try
while
with
yield

106
3.2.2
e
e
a
rsoudre une srie de probl`mes quivalents. Dans ce contexte, cest le paramtrage de lalgoe
e
e
e
e
rithme qui lui donnera cette capacit recherche de rsoudre des probl`mes quivalents. Dans
e
e
e
e
e
lexemple de la fonction sin, cest en eet le param`tre x qui permet de calculer le sinus de
e
nimporte quel nombre rel (sin(x)) et non le sinus dun seul nombre. La deuxi`me tape de
e
e
e
la dnition dune fonction consiste donc ` prciser les param`tres dentre-sortie de la fonction
e
a e
e
e
(gure 3.6).
`
Fig. 3.6 : Parametres dune fonction
sin
Paramtrer
e
sin est le nom de la fonction ; x est le seul param`tre

e
dentre, y le seul param`tre de sortie.
e
e
Dnition 3.5 : parametre dentree

e
Les param`tres dentre dune fonction sont les arguments de la fonction qui sont ncessaires
e
e
e
pour eectuer le traitement associ ` la fonction.
ea
`
Dnition 3.6 : parametre de sortie
e
Les param`tres de sortie dune fonction sont les rsultats retourns par la fonction apr`s avoir
e
e
e
e
eectu le traitement associ ` la fonction.
e
ea
y = sin(x)
a
s
b
functionName
t
functionName est le nom de la fonction ; a, b et

c sont les 3 param`tres dentre, s et t les 2 pae
e
ram`tres de sortie.
e
(s,t) = functionName(a,b,c)
Pour cela, on nomme ces param`tres avec des identicateurs explicites dans le contexte
e
courant dutilisation de la fonction. Les param`tres de sortie seront systmatiquement initialiss
e
e
e
a
` une valeur par dfaut (par exemple : 0 pour un entier, False pour un boolen, 0.0 pour un
e
e
rel, pour une cha de caract`res, [] pour un tableau).
e
ne
e
La fonction fibonacci prend lordre n en param`tre dentre et retourne le nombre u (un ).
e
e
Le param`tre de sortie u est un entier qui sera donc a priori initialis ` 0 dans la fonction et qui
e
ea
sera retourn par la fonction (return u).
e
def fibonacci(n):
u = 0
return u
>>>
>>>
0
>>>
0
>>>
0
from fibo import fibonacci

fibonacci(5)
fibonacci(-5)
fibonacci(n)
Le code de la partie gauche est la nouvelle dnition de la fonction fibonacci toujours dite
e
e e
dans le mme chier fibo.py que prcdemment. La partie droite montre son utilisation sous
e
e e
linterprteur Python. Dans ltat actuel, cette fonction retourne 0 quels que soient le type
e
e
et la valeur du param`tre dentre ! Mais elle est encore compilable et excutable. On peut
e
e
e

107
e
maintenant la dcrire de la mani`re suivante : u = fibonacci(n) est le ni`me nombre de
e
e
Fibonacci (gure 3.7). Cette description est un peu moins littraire que dans la section
e
3.2.1 prcdente. Elle a cependant lavantage de montrer lutilisation typique de la fonction (u
e e
= fibonacci(n)) et dexpliciter le sens des param`tres dentre-sortie (n et u).
e
e
Fig. 3.7 : Fonction fibonacci (1)
3.2.3
Protger
e
Dans la section prcdente, nous avons test la fonction fibonacci avec comme param`tre
e e
e
e
dentre la cha de caract`res n : cela na aucun sens pour le calcul dun nombre de Fibonacci !
e
ne
e
Il faut donc protger la fonction pour la rendre plus robuste face ` des contextes anormaux
e
a
dutilisation (gure 3.8). Pour cela, on imposera aux param`tres dentre de vrier certaines
e
e
e
conditions avant dexcuter la fonction appele. Ces conditions pralables ` lexcution sont
e
e
e
a
e
appeles les prconditions.
e
e
Dnition 3.7 : precondition

e
Les prconditions dune fonction sont les conditions que doivent imprativement vrier les
e
e
e
param`tres dentre de la fonction juste avant son excution.
e
e
e
Une prcondition est donc une expression boolenne qui prend soit la valeur False (faux)
e
e
soit la valeur True (vrai). Elle peut contenir des oprateurs de comparaison (==, !=, >, >=, <=,
e
<), des oprateurs logiques (not, and, or), des oprateurs didentit (is, is not), des oprateurs
e
e
e
e
dappartenance (in, not in) ou toutes autres fonctions boolennes. En Python, on dnira les
e
e
prconditions que doivent vrier les param`tres dentre de la fonction ` laide de la directive
e
e
e
e
a
assert (gure 3.9). A lexcution du code, cette directive l`vera une exception si la condition
e
e
(lassertion, gure 3.10) teste est fausse. Les prconditions seront places systmatiquement
e
e
e
e
juste apr`s len-tte de la fonction (def fibonacci(n) :).
e
e
def fibonacci(n):
assert type(n) is int
assert n >= 0
u = 0
return u
>>> fibonacci(-5)
Traceback ...
assert n >= 0
AssertionError
>>> fibonacci(n)
Traceback ...
AssertionError
La dnition de la fonction fibonacci a donc t complte par les prconditions sur le pae
ee
ee
e
ram`tre dentre : n doit tre un entier (type(n) is int) positif ou nul (n >= 0). Sa descripe
e
e
fibonacci
fibonacci est le nom de la fonction ; n est le seul

param`tre dentre, u le seul param`tre de sortie.
e
e
e
u = fibonacci(n)
Fig. 3.8 : Robustesse dun algorithme

La robustesse dun algorithme est son aptitude ` se
a
protger de conditions anormales dutilisation.
e
Fig. 3.9 : Linstruction assert en Python

assert expr[, message]
expr est value : si expr == True, on passe ` linse
e
a
truction suivante, sinon lexcution est interrompue
e
et une exception AssertionError est leve qui afe
che le message optionnel.
Exemple :
>>> assert False, "message derreur"
Traceback (most recent call last) :
File "<stdin>", line 1, in <module>
AssertionError : message derreur
>>>

108
Fig. 3.10 : Definition de lAcademie (8)

ASSERTION n. f. XIIIe si`cle. Emprunt du latin
e
e
assertio, driv de assertum, supin de asserere,
e e
revendiquer , puis prtendre, armer . Propoe
sition quon avance et quon soutient comme vraie.
Dnition 3.8 : postcondition

e
Les postconditions dune fonction sont les conditions que doivent imprativement vrier les
e
e
param`tres de sortie de la fonction juste apr`s son excution.
e
e
e
n:int
fibonacci
tion peut alors tre complte pour tenir compte de ces prconditions sur lordre n du nombre
e
ee
e
e
de Fibonacci calcul : u = fibonacci(n) est le ni`me nombre de Fibonacci si n :int >= 0
e
(gure 3.11). La fonction est toujours compilable et excutable, mais son excution est maine
e
tenant systmatiquement interrompue si les prconditions ne sont pas respectes : ce qui est le
e
e
e
cas pour les param`tres dentre -5 et n. Dans tous les autres cas (entiers positifs ou nuls),
e
e
elle retourne toujours 0 !
En Python, la mani`re dont nous avons initialis le param`tre de sortie u (u = 0) indique
e
e
e
quil sagit implicitement dun entier (int). La fonction fibonacci retourne donc un entier : cest
une postcondition sur le param`tre de sortie u dans le cas du calcul dun nombre de Fibonacci.
e
u:int
En plus des prconditions et des postconditions, on pourra quelquefois imposer que des
e
conditions soient vries tout au long de lexcution de la fonction : on parle alors dinvariants.
e e
e
[n >= 0]
n :int est le param`tre dentre de nom n et de type

e
e
int qui doit vrier la prcondition [n >= 0].
e
e
u :int est la param`tre de sortie de nom u et de
e
type int.
u = fibonacci(n)
Dnition 3.9 : invariant

e
Les invariants dune fonction sont les conditions que doit imprativement vrier la fonction
e
e
tout au long de son excution.
e
De tels exemples dinvariants seront mis en vidence lors de limplmentation de certaines fonce
e
tions.
3.2.4
Tester
Avant mme dimplmenter la fonction proprement dite (voir section 3.2.6), on dnit des
e
e
e
tests que devra vrier la fonction une fois implmente. Ces tests sont appels tests unitaires
e
e
e
e
car ils ne concernent quune seule fonction, la fonction que lon cherche ` dnir. Ce jeu de
a e
tests constitue ainsi un ensemble caractristique dentres-sorties associes que devra vrier
e
e
e
e
la fonction. Par exemple, fibonacci(0) devra retourner 1, fibonacci(1) devra retourner 1,
fibonacci(2) devra retourner 2 ou encore fibonacci(9) devra retourner 55. En fait, quelle que
soit la mani`re dont sera implmente la fonction fibonacci, les rsultats prcdents devront
e
e
e
e
e e
tre obtenus par cette implmentation.
e
e
En Python, on utilisera une docstring (cha entre 3 guillemets : """ ... """) pour
ne
dcrire ces tests. Cette cha spciale, place entre len-tte et les prconditions et qui peut
e
ne e
e
e
e

109
tenir sur plusieurs lignes, joue le rle de commentaire dans le corps de la fonction. Elle ne
o
change donc a priori rien ` son excution courante.
a
e
def fibonacci(n):
"""
>>> fibonacci(0)
1
>>> fibonacci(2)
2
>>> fibonacci(9)
55
"""
assert n >= 0
u = 0
return u
>>> fibonacci(0)
0
>>> fibonacci(2)
0
>>> fibonacci(9)
0
Nous avons donc ajouter 3 tests dans la dnition de la fonction fibonacci. En Python, ces
e
tests ont la particularit de se prsentent sous la mme forme que lorsquon appelle la fonction
e
e
e
sous linterprteur Python, ` ceci pr`s quils sont crits dans une docstring (""" ... """) :
e
a
e
e
"""
>>> fibonacci(0)
1
>>> fibonacci(2)
2
>>> fibonacci(9)
55
"""
>>> fibonacci(0)
0
>>> fibonacci(2)
0
>>> fibonacci(9)
0
La fonction est toujours compilable et excutable, et son excution retourne toujours 0. Si

e
e
maintenant, nous ajoutons les 3 lignes ci-dessous ` la n du chier fibo.py, les tests que nous
a
avons ajouts ` la dnition de la fonction fibonacci vont tre valus automatiquement (gure
e a
e
e e
e
3.12) comme le montre lexcution de la page suivante.
e
if __name__ == "__main__" :
import doctest
doctest.testmod()
Dune certaine mani`re ces tests permettent de prciser ce quon attend de la fonction. Le choix
e
e
de ces tests est donc tr`s important pour valider limplmentation future.
e
e
Fig. 3.12 : Le module doctest

Le module doctest est un module standard Python
qui ore des services pour manipuler les docstrings
utilises dans les jeux de tests :
e
www.python.org/doc/2.5/lib/module-doctest.html
The doctest module searches for pieces of text that
look like interactive Python sessions, and then executes those sessions to verify that they work exactly
as shown. There are several common ways to use
doctest :
To check that a modules docstrings are up-to-date
by verifying that all interactive examples still work
as documented.
To perform regression testing by verifying that interactive examples from a test le or a test object
work as expected.
To write tutorial documentation for a package, liberally illustrated with input-output examples. Depending on whether the examples or the expository
text are emphasized, this has the avor of literate
testing or executable documentation.
The functions testmod() and testfile() provide a
simple interface to doctest that should be sucient
for most basic uses.

110
$ python fibo.py
**********************************************
File "fibo.py", line 10, in __main__.fibonacci
Failed example:
fibonacci(0)
Expected:
1
Got:
0
**********************************************
Failed example:
fibonacci(2)
Expected:
2
Got:
0
**********************************************
Failed example:
fibonacci(9)
Expected:
55
Got:
0
**********************************************
1 items had failures:
3 of
3 in __main__.fibonacci
***Test Failed*** 3 failures.
$
On lance linterprteur Python en passant

e
le chier ` tester (ici fibo.py). Chaque test
a
du jeu de tests plac dans la docstring
e
de la fonction ` tester sera excut par
a
e e
linterprteur. Si le rsultat du test est
e
e
conforme ` ce qui tait prvu (par exemple
a
e
e
factorielle(0) 1), rien de particulier
ne se passe. Si le test est en erreur, Python
prcise la ligne du chier o` appara le
e
u
t
test (par exemple : File "fibo.py", line
10), le test en erreur (fibonacci(0)),
le rsultat attendu (Expected : 1) et le
e
rsultat obtenu (Got : 0). Ainsi, on peut
e
vrier simplement si la fonction a pass le
e
e
jeu de tests. Cest une mani`re de tester la
e
validit de limplmentation.
e
e
Ces tests seront conservs tant que la fonctionnalit est requise. A chaque modication du code,
e
e
on eectuera tous les tests ainsi dnis pour vrier si quelque chose ne fonctionne plus.
e
e
3.2.5
Dcrire
e
Une fois choisis le nom de la fonction, les param`tres dentre-sortie, les prconditions sur
e
e
e
les param`tres dentre et les jeux de tests, on peut alors prciser ce que fait lalgorithme et
e
e
e
dans quelles conditions il le fait : il sagit dune phrase de description en bon franais qui
c
permettra ` tout utilisateur de comprendre ce que fait lalgorithme sans ncessairement savoir
a
e

111
comment il le fait.
Dnition 3.10 : description dune fonction
e
La description dune fonction est une phrase qui prcise ce que fait la fonction et dans quelles
e
conditions elle le fait.
Cette phrase est une cha de caract`res qui doit expliciter le rle des param`tres dentre et
ne
e
o
e
e
leurs prconditions, ainsi que toutes autres informations juges ncessaires par le concepteur de
e
e
e
la fonction. En particulier, lorsque le retour de la fonction nest pas vident , on explicitera les
e
param`tres de sortie. Dans le cas de la fonction fibonacci, un utilisateur de la fonction saura
e
ce quest un nombre de Fibonacci et la prcision que cette fonction retourne un entier nest pas
e
ncessaire. Par contre, si la fonction retourne plus dune valeur, il faut au moins prciser lordre
e
e
dans lequel elle les retourne. Ainsi par exemple, pour la fonction divmod(a,b) de la biblioth`que
e
standard Python qui calcule le quotient q et le reste r de la division enti`re a b (voir annexe
e
3.5.2 page 153), il faut prciser quelle retourne un n-uplet (tuple) dans lordre (q,r). Dans
e
certains cas, il faut galement prciser que la fonction eectue les calculs dans telles ou telles
e
e
units : cest par exemple le cas des fonctions trigonomtriques usuelles o` les calculs sont mens
e
e
u
e
avec des angles en radians (gure 3.3 page 102). Dans dautres cas encore, on pourra prciser
e
une rfrence bibliographique ou un site Web o` lutilisateur pourra trouver des complments
ee
u
e
sur la fonction et lalgorithme associ. La description dune fonction int`grera donc au moins :
e
e
un exemple typique dappel de la fonction,
la signication des param`tres dentre-sortie,
e
e
les prconditions sur les param`tres dentre,
e
e
e
un jeu de tests signicatifs.
Ainsi, la description de la fonction fibonacci pourra se prsenter sous la forme suivante :
e
u = fibonacci(n) est le nombre de Fibonacci ` lordre n si n :int >= 0.
a
Exemples : fibonacci(0) 1, fibonacci(2) 2, fibonacci(9) 55 .
En Python, on int`grera cette description dans la docstring (cha entre 3 guillemets)
e
ne
que lon a dj` utilise pour le jeu de tests. Les exemples seront donns sous la forme dun jeu
ea
e
e
de tests ` la Python. Cette cha spciale, qui peut tenir sur plusieurs lignes, joue le rle de
a
ne e
o
commentaire dans le corps de la fonction. Elle ne change donc rien ` son excution. Par contre,
a
e
elle permettra de documenter automatiquement laide en-ligne de Python (help) ou encore, elle
pourra tre utilise par certains environnements (idle par exemple) ou par certains utilitaires
e
e
comme pydoc (voir annexe 3.5.4 page 156).

112
def fibonacci(n):
"""
u = fibonacci(n)
est le nombre de Fibonacci
a
` lordre n si n:int >= 0
>>> fibonacci(0)
1
>>> fibonacci(2)
2
>>> fibonacci(9)
55
"""
assert n >= 0
u = 0
return u
TD 3.3 : Decodage base b decimal

En section 3.1.1, la valeur dcimale dun nombre entier
e
cod en base b tait obtenu par lalgorithme suivant :
e
e
>>> n = 0
>>> for i in range(len(code)) :
...
...
>>>
Spcier une fonction qui encapsulera cet algorithme.
e
>>> fibonacci(5)
0
>>> fibonacci(100)
0
>>> help(fibo.fibonacci)
Help on function fibonacci in module fibo:
fibonacci(n)
u = fibonacci(n)
a
>>> fibonacci(0)
1
>>> fibonacci(2)
2
>>> fibonacci(9)
55
La fonction est toujours compilable et excutable ; elle est maintenant documentable (help(fibo.
e
fibonacci)), mais retourne toujours 0 ! Il reste ` limplmenter.
a
e
TD3.3
Spcication :
e
3.2.6
fibonacci
n:int
u:int
[n >= 0]
u = fibonacci(n) est le nombre de Fibonacci

a
` lordre n si n :int >= 0.
Exemples : fibonacci(0) 1
fibonacci(2) 2
fibonacci(9) 55
Implmentation :
e
fibonacci
u = 1
u1 = 1
u2 = 1
i = 2
n:int
[n >= 0]
u1:int
u2:int
i:int
[i in 2..n]
[else]
u = u1 + u2
u2 = u1
u1 = u
i = i + 1
u:int
Encapsuler
La derni`re tape consiste enn ` dire comment fait la fonction pour rpondre ` la
e e
a
e
a
spcication dcrite au cours des tapes prcdentes. En phase de spcication, la fonction
e
e
e
e e
e
(ou la procdure) est vue comme une bo noire dont on ne conna pas le fonctionnement
e
te
t
interne (gure 3.13 : spcication). En phase dimplmentation, lencha
e
e
nement des instructions
ncessaires ` la rsolution du probl`me considr est dtaill (gure 3.13 : implmentation).
e
a
e
e
ee
e
e
e
>>>
9
>>>
>>>
...
...
...
...
>>>
55
n
u, u1, u2 = 1, 1, 1
for i in range(2,n+1):
u = u1 + u2
u2 = u1
u1 = u
u
Compte-tenu de la dnition des nombres

e
de Fibonacci (exemple 3.4), les instructions ci-contre permettent de calculer le
nombre u de Fibonacci pour un ordre n
donn (ici 9). Pour chaque valeur de i, u1
e
reprsente initialement le nombre de Fiboe
nacci ` lordre (i-1), u2 le nombre de Fia
bonacci ` lordre (i-2) et u (= u1 + u2)
a
le nombre de Fibonacci ` lordre i.
a
Ce sont ces instructions quil faut encapsuler au cur de la fonction fibonacci comme le

113
montre le code complet ci-dessous (voir remarque 3.3).

def fibonacci(n):
"""
u = fibonacci(n)
a
>>> fibonacci(0)
1
>>> fibonacci(2)
2
>>> fibonacci(9)
55
"""
assert n >= 0
u, u1, u2 = 1, 1, 1
for i in range(2,n+1):
u = u1 + u2
u2 = u1
u1 = u
return u
TD3.4

>>> for n in range(10):
...
print(fibonacci(n),end= )
...
1 1 2 3 5 8 13 21 34 55
>>> for n in range(10,60,10):
...
print(fibonacci(n),end= )
...
89 10946 1346269 165580141 20365011074
>>> fibonacci(100)
573147844013817084101L
>>> fibo.fibonacci(120)
8670007398507948658051921L
>>> fibonacci(200)
453973694165307953197296969697410619233826L
En fait, plusieurs implmentations peuvent correspondre ` la mme spcication. Cest le cas

e
a
e
e
par exemple pour le calcul de la somme des n premiers nombres entiers ci-dessous.
def sommeArithmetique(n):
"""
s = sommeArithmetique(n) est la somme
des n premiers entiers si n:int >= 0
...
print(sommeArithmetique(n)\
== n*(n+1)/2,end= )
True True True True True True True
"""
assert n >= 0
s = n*(n+1)/2
def sommeArithmetique(n):
"""
s = sommeArithmetique(n) est la somme
des n premiers entiers si n:int >= 0
...
print(sommeArithmetique(n)\
== n*(n+1)/2,end= )
True True True True True True True
"""
assert n >= 0
s = 0
for k
in range(1,n+1): s = s + k
return s
return s
Limplmentation de gauche repose directement sur le rsultat mathmatique bien connu

e
e
e
Remarque 3.3 : La suite de Fibonacci doit son nom

au mathmaticien italien Fibonacci (1175-1250). Dans
e
un probl`me rcratif, Fibonacci dcrit la croissance
e
e e
e
dune population idale de lapins de la mani`re suie
e
vante :
le premier mois, il y a juste une paire de lapereaux ;
les lapereaux ne sont pub`res qu` partir du deuxi`me
e
a
e
mois ;
chaque mois, tout couple susceptible de procrer ene
gendre eectivement un nouveau couple de lapereaux ;
les lapins ne meurent jamais !
Se pose alors le probl`me suivant :
e
Possdant initialement un couple de lae
pins, combien de couples obtient-on en
douze mois si chaque couple engendre tous
les mois un nouveau couple ` compter du
a
second mois de son existence ?
Ce probl`me est ` lorigine de la suite de Fibonacci dont
e
a
e
le ni`me terme correspond au nombre de couples de lae
pins au ni`me mois. Au bout dun an, il y aura donc
fibonacci(12) (= 233) couples de lapins dans cette population idale . On nose ` peine imaginer ce que
e
a
serait cet univers idal de lapins au bout de 10 ans
e
(8670007398507948658051921 couples !). . .
TD 3.4 : Codage des entiers positifs (2)
Dnir (spcier et implmenter) une fonction qui code
e
e
e
un entier n en base b sur k chires (voir TD 3.1).

114
Remarque 3.4 : La somme S des n premiers nombres

entiers est telle que :
S=
n
X
k = (1 + 2 + 3 + + n) =
k=1
n(n + 1)
2
En eet :
S
S
2S
=
=
=
1
n
(n + 1)
+
+
+
2
n1
(n + 1)
+
+
+
+
+
+
n
1
(n + 1)
do` : 2S = n(n + 1)
u
TD 3.5 : Une specification, des implementations

1. Proposer deux implmentations du calcul de la
e
Pn
somme s =
0 uk des n premiers termes dune
suite gomtrique uk = a bk .
e e
2. Comparer les complexits de ces deux implmene
e
tations.
concernant les suites arithmtiques (s = n*(n+1)/2 : voir remarque 3.4). Limplmentation de

e
e
droite eectue la somme 1 ` 1 des n premiers lments (s = s + k). Ces deux implmentations
a
ee
e
sont toutes les deux conformes au jeu de tests, mais elles ne se valent pas en terme de complexit.
e
La premi`re est dite ` temps constant : quelle que soit la valeur de n, le calcul ne ncessitera
e
a
e
jamais plus de 3 oprations ((n+1), n*(n+1) et n*(n+1)/2). La seconde est dite ` temps
e
a
linaire : le nombre doprations (s + k) dpend linairement de n (il y a (n 1) additions `
e
e
e
e
a
calculer pour n > 1). La premi`re implmentation est donc plus ecace que la deuxi`me et lui
e
e
e
sera prfre.
eee
TD3.5
Ce sera le rle du concepteur dun algorithme de dnir sa spcication et den proposer une
o
e
e
implmentation ecace. Lutilisateur de la fonction, quant ` lui, na pas ` conna limplmene
a
a
tre
e
tation ; seule la spcication de la fonction le concerne car elle lui est ncessaire pour appeler la
e
e
fonction.
3.2.7
Conclure
Lalgorithmique, ou science des algorithmes, sintresse ` lart de construire des algorithmes

e
a
ainsi qu` caractriser leur validit, leur robustesse leur rutilisabilit, leur complexit ou encore
a
e
e
e
e
e
leur ecacit. Certaines de ces caractristiques gnrales (validit, robustesse, rutilisabilit) se
e
e
e e
e
e
e
concr`tisent ` la lumi`re des prconisations prcdentes concernant la dnition dune fonction.
e
a
e
e
e e
e
Validit : La validit dun algorithme est son aptitude ` raliser exactement la tche pour
e
e
a e
a
laquelle il a t conu.
ee
c
ie : Limplmentation de la fonction doit tre conforme aux jeux de tests.
e
e
Robustesse : La robustesse dun algorithme est son aptitude ` se protger de conditions anora
e
males dutilisation.
ie : La fonction doit vrier imprativement ses prconditions.
e
e
e
Rutilisabilit : La rutilisabilit dun algorithme est son aptitude ` tre rutilis pour rsoudre
e
e
e
e
ae
e
e
e
des tches quivalentes ` celle pour laquelle il a t conu.
a
e
a
ee
c
ie : La fonction doit tre correctement paramtre.
e
e e
Une fois la fonction dnie (spcie et implmente), il reste ` lutiliser (` lappeler).
e
e e
e
e
a
a
3.3. APPEL DUNE FONCTION
3.3
115
Appel dune fonction
Une fonction sutilise (s appelle ) sous la forme du nom de la fonction suivi de parenth`ses
e
a
` lintrieur desquelles on transmet (on passe ) zro ou plusieurs arguments conformment
e
e
e
a
` la spcication de la fonction. Dans le cas de la fonction fibonacci, on doit transmettre un
e
argument et un seul lors de lappel de la fonction.
>>> fibonacci(9)
55
>>> fibonacci(5+4)
55
>>> fibonacci(8) + fibonacci(7)
55
>>>
>>>
55
>>>
>>>
>>>
55
y = fibonacci(9)
y
x = 9
y = fibonacci(x)
y
Largument transmis peut tout aussi bien tre une constante (par exemple 9), une variable (par
e
exemple x) ou toute expression dont la valeur est un entier positif ou nul (par exemple 5+4).
Mais quel rapport existe-t-il entre ces arguments transmis et les param`tres dentre-sortie de
e
e
la fonction (n et u dans le cas de la fonction fibonacci) ? Cest le probl`me du passage des
e
param`tres de linstruction appelante ` la fonction appele.
e
a
e
3.3.1
Passage des param`tres

e
Dans la dnition dune fonction, la liste des param`tres dentre spcie les informations `
e
e
e
e
a
transmettre comme arguments lors de lappel de la fonction. Les arguments eectivement utiliss
e
doivent tre fournis dans le mme ordre que celui des param`tres dentre correspondants : le
e
e
e
e
premier argument sera aect au premier param`tre dentre, le second argument sera aect
e
e
e
e
au second param`tre dentre, et ainsi de suite.
e
e
Dnition :
e
Appel :
def fibonacci(n):
...
return u
>>> y = fibonacci(x)
Les param`tres introduits dans la dnition sont appels les param`tres formels (par exemple
e
e
e
e
n dans la dnition de la fonction fibonacci) ; les param`tres passs en arguments sont appels
e
e
e
e
les param`tres eectifs (par exemple x dans lappel fibonacci(x)).
e

116
`
Dnition 3.11 : parametre formel
e
Un param`tre formel est un param`tre dentre dune fonction utilis ` lintrieur de la fonction
e
e
e
ea
e
appele.
e
`
Dnition 3.12 : parametre effectif
e
Un param`tre eectif est un param`tre dappel dune fonction utilis ` lextrieur de la fonction
e
e
ea
e
appele.
e
TD 3.6 : Passage par valeur

On consid`re les codes suivants :
e
>>> x, y
def swap(x,y) :
>>> x, y
(1, 2)
tmp = x
(1, 2)
>>> tmp = x
x = y
>>> swap(x,y)
>>> x = y
y = tmp
>>> x, y
>>> y = tmp
return
(1, 2)
>>> x, y
(2, 1)
Expliquer la dirence entre lexcution de gauche et
e
e
lexcution de droite en explicitant lappel quivalent `
e
e
a
lappel swap(x,y) dans lexcution de droite.
e
Lors de lappel dune fonction, il y a copie des param`tres eectifs dans les param`tres
e
e
formels : les valeurs des param`tres eectifs passs en argument sont aectes aux param`tres
e
e
e
e
formels dentre correspondants (on parle de passage par valeur ou de passage par copie ).
e
Ainsi, ce ne sont pas les param`tres eectifs qui sont manipuls par la fonction elle-mme mais
e
e
e
des copies de ces param`tres. A la sortie de la fonction, on copie la valeur du param`tre formel de
e
e
retour (u dans la fonction fibonacci) dans un param`tre eectif qui remplace temporairement
e
lappel de la fonction (fibonacci(x)) et qui est nalement utilis par linstruction qui a appel la
e
e
fonction (laectation dans le cas de linstruction y = fibonacci(x)). Cette variable temporaire
est ensuite dtruite automatiquement. Ainsi, linstruction y = fibonacci(x) est quivalente
e
e
a
` la squence dinstructions suivante :
e
TD3.6
Dnition :
e
def fibonacci(n) :
u, u1, u2 = 1, 1, 1
u = u1 + u2
u2 = u1
u1 = u
return u
Appel :
>>> x = 9
>>> y = fibonacci(x)
>>> y
55
Appel quivalent :
e
>>> x = 9
>>> n = x
>>> u, u1, u2 = 1, 1, 1
>>> for i in range(2,n+1) :
...
u = u1 + u2
...
u2 = u1
...
u1 = u
...
>>> tmp = u
>>> del n, u, u1, u2, i
>>> y = tmp
>>> del tmp
>>> y
55
On commence par copier la valeur du param`tre eectif x dans le param`tre formel dentre n
e
e
e
(n = x) ; en Python, n est vraiment cre ` ce moment l` seulement. On excute ensuite tel
ee a
a
e
quel le code de la fonction fibonacci : les variables internes ` la fonction (u, u1, u2, i) sont
a
cres et manipules conformment ` la dnition de fibonacci. Linstruction return u
ee
e
e
a
e
117
provoque ensuite la cration dune variable temporaire tmp dans laquelle on copie la valeur du
e
param`tre formel de sortie u (tmp = u) et toutes les variables introduites dans le corps de la
e
fonction sont dtruites (del n, u, u1, u2, i). On aecte la valeur de tmp ` y (y = tmp) : cette
e
a
aectation ralise eectivement laectation souhaite (y = fibonacci(x)). Enn, la variable
e
e
temporaire tmp introduite au retour de la fonction fibonacci est dtruite (del tmp). A la
e
n, seules coexistent les deux variables x et y : toutes les autres variables (n, u, u1, u2, i et tmp)
ont t cres temporairement pour les besoins de lappel de la fonction, puis dtruites.
e e ee
e
Dnition 3.13 : passage par valeur

e
Le passage des param`tres par valeur (ou par copie) consiste ` copier la valeur du param`tre
e
a
e
eectif dans le param`tre formel correspondant.
e
Dans certains cas, le param`tre eectif occupe une trop grande place en mmoire pour
e
e
envisager de le recopier. Par exemple, une image satellite de 6000 6000 pixels cods sur 8
e
niveaux de gris occupe 36M o en mmoire ; la copier conduirait ` occuper 72M o ! Par ailleurs, on
e
a
peut vouloir eectuer un traitement sur limage originale et non traiter une de ses copies. Pour
remedier ` ces probl`mes lis au passage des param`tres par valeur, on utilisera le passage
a
e
e
e
par rfrence qui consiste ` transfrer la rfrence de la variable (son nom ou son adresse en
ee
a
e
ee
mmoire) plutt que sa valeur.
e
o

Dnition 3.14 : passage par reference
e
Le passage des param`tres par rfrence consiste ` copier la rfrence du param`tre eectif dans
e
ee
a
ee
e
le param`tre formel correspondant.
e
En Python, certains types de variables utilisent systmatiquement le passage par rfrence :

e
ee
cest le cas des listes (type list), des dictionnaires (type dict) ou encore des classes (types dnis
e
par le programmeur).

118
def f(x):
assert type(x) is list
if len(x) > 0: x[0] = 5
return
>>>
>>>
>>>
[5,
t = [0,1,2]
f(t)
t
1, 2]
def g(x):
assert type(x) is list
y = [9,8,7]
x = y
x[0] = 5
return
>>>
>>>
>>>
[0,
t = [0,1,2]
g(t)
t
1, 2]
Les fonctions f() et g() ncessitent chacune un argument de type list (assert type(x) is
e
list). Cet argument sera donc pass par rfrence lors de lappel de ces fonctions : ` lintrieur
e
ee
a
e
de chacune delles, on manipulera une copie de la rfrence de la liste passe en argument (t
ee
e
dans les exemples de droite). La fonction f() cherche ` modier le premier lment de la liste
a
ee
(x[0] = 5) : elle aecte au premier lment de la liste nomme x (llment de rang 0 : x[0])
ee
e
ee
la valeur 5. Comme le param`tre formel x est une copie de la rfrence originale t, il rfrence
e
ee
ee
le mme tableau de valeurs [0,1,2] et la modication portera bien sur llment 0 du tableau
e
ee
original. A la sortie de la fonction f(), la liste t originale est bien modie. Quant ` elle, la
e
a
fonction g() cherche ` modier la rfrence de la liste x (x = y). En fait, elle modie la copie
a
ee
de la rfrence (x) mais pas la rfrence originale (t). Laectation suivante (x[0] = 5) modie
ee
ee
ainsi le premier lment du tableau de valeurs [9,8,7]. Mais, ` la sortie de la fonction g(),
ee
a
le tableau de valeurs [0,1,2] rfrenc par la liste t originale nest pas modi. Les mmes
ee
e
e
e
fonctionnements sont obtenus avec un dictionnaire comme le montrent les exemples ci-dessous.
def f(x):
assert type(x) is dict
x[0] = 5
return
>>>
>>>
>>>
{0:
d = {}
f(d)
d
5}
def g(x):
assert type(x) is dict
y = {0: 9, 1: 8, 2: 7}
x = y
x[0] = 5
return
>>> d = {}
>>> g(d)
>>> d
{}
3.3.2
119
Param`tres par dfaut

e
e
Dans la dnition dune fonction, il est possible de dnir une valeur par dfaut pour chacun
e
e
e
des param`tres dentre. On peut dnir une valeur par dfaut pour tous les param`tres, ou
e
e
e
e
e
une partie dentre eux seulement ; dans ce cas, les param`tres sans valeur par dfaut doivent
e
e
prcder les autres dans la liste. On obtient ainsi une fonction qui peut tre appele avec tous
e e
e
e
ses param`tres ou une partie seulement des arguments attendus :
e
def f(x, y = 0, z = r):
return x,y,z
>>> f(1,2,t)
(1, 2, t)
>>>
(1,
>>>
(1,
>>> f()
Traceback ...
TypeError: f() takes at least 1 argument
(0 given)
f(1,2)
2, r)
f(1)
0, r)
De nombreuses fonctions des biblioth`ques standards poss`dent des arguments par dfaut. Cest
e
e
e
le cas par exemple de la fonction standard int() (voir annexe 3.5.2 page 153) ou encore de la
fonction log() du module math (voir gure 3.3 page 102).
>>> int(45)
45
>>> int(45,10)
45
>>> int(101101,2)
45
>>> int(45,23)
97
>>> int(45,23) == 4*23**1 + 5*23**0
True

>>> e
2.7182818284590451
>>> log(e)
1.0
>>> log(e,e)
1.0
>>> log(e,10)
0.43429448190325176
>>> log(pi,7) == log(pi)/log(7)
True
A gauche, la fonction int() permet de transformer en un entier dcimal une cha de caract`res
e
ne
e
eme argument
`
(par exemple 45) qui reprsente un nombre crit dans la base spcie par le 2
e
e
e e
(par exemple 23). Par dfaut, cette base est la base dcimale (10). A droite, la fonction log()
e
e
calcule le logarithme dun nombre (par exemple 2.7182818284590451) dans la base spcie par
e e
eme argument (par exemple 10). Par dfaut, cette base est celle des logarithmes npriens
`
le 2
e
e e
(e).
TD3.7
Dans la plupart des langages de programmation, les arguments que lon transmet ` lappel
a
dune fonction doivent tre passs exactement dans le mme ordre que celui des param`tres qui
e
e
e
e
leur correspondent dans la dnition de la fonction. En Python, si les param`tres annoncs
e
e
e
TD 3.7 : Valeurs par defaut

On consid`re la fonction qui code en base b sur k
e
chires un nombre dcimal n (voir TD 3.4). Proposer
e
une dnition de cette fonction o` k = 8 et b = 2 par
e
u
dfaut.
e

120
dans la dnition de la fonction ont reu chacun une valeur par dfaut, on peut faire appel ` la
e
c
e
a
fonction en fournissant les arguments correspondants dans nimporte quel ordre, ` condition de
a
dsigner nommment les param`tres correspondants.
e
e
e
def f(x = 0, y = 1):
return x,y
>>> f()
(0, 1)
>>> f(3)
(3, 1)
Remarque 3.5 : En Python, lespace de noms dune

fonction peut tre connu grce ` deux fonctions stane
a a
dards : dir et locals (voir annexe 3.5.2 page 153). La
fonction dir retourne la liste des variables locales ` la
a
fonction. La fonction locals retourne le dictionnaire
variable :valeur des variables locales.
>>> def f(x) :
...
y = 3
...
x = x + y
...
print(liste :, dir())
...
print(intrieur :, locals())
e
...
print(extrieur :, globals())
e
...
return x
...
>>> y = 6
>>> f(6)
liste : [x, y]
intrieur : {y : 3, x : 9}
e
extrieur : {f : <function f at 0x822841c>,
e
y : 6,
name : main ,
doc : None}
9
La fonction standard globals retourne le dictionnaire
des variables globales. On constate quil y a bien 2 variables y, lune globale qui vaut 6 et lautre, locale, qui
vaut 3.
>>>
(3,
>>>
(0,
>>>
(8,
>>> f(3,4)
(3, 4)
f(y = 4, x = 3)
4)
f(y = 6)
6)
f(x = 8)
1)
La fonction f() a 2 param`tres dentre (x et y) qui admettent chacun une valeur par dfaut
e
e
e
(respectivement 0 et 1). On peut lappeler classiquement avec 0, 1 ou 2 arguments comme dans
les 3 appels de gauche (f(), f(3), f(3,4)). On peut aussi lappeler en nommant explicitement
les arguments comme dans les 3 exemples de droite (f(y = 4, x = 3), f(y = 6), f(x = 8)) ;
dans ce cas, lordre des param`tres na plus dimportance.
e
>>> def f(x = 0, y = 1):
...
return x,y
...
>>> x = 7
>>> f(x = x)
(7, 1)
Dans ce dernier exemple, comment distinguer le param`tre formel x et le param`tre eectif x

e
e
dans lappel f(x = x) ? Cest le probl`me de la porte des variables.
e
e
3.3.3
Porte des variables

e
Les noms des param`tres eectifs nont ainsi rien de commun avec les noms des param`tres
e
e
formels correspondants : il ne reprsente pas la mme variable en mmoire. . . mme sils ont le
e
e
e
e
mme nom !
e
Lorsquon dnit des variables ` lintrieur du corps dune fonction, ces variables ne sont
e
a
e
accessibles qu` la fonction elle-mme. On dit que ces variables sont des variables locales ` la
a
e
a
fonction : en quelque sorte, elles sont connes ` lintrieur de la fonction. Cest par exemple le
e a
e
cas des variables n, u, u1, u2 et i de la fonction fibonacci (voir section 3.2.6). Chaque fois que
la fonction fibonacci est appele, Python rserve pour elle en mmoire un nouvel espace de
e
e
e
noms . Les valeurs des variables locales n, u, u1, u2 et i sont ainsi stockes dans cet espace de
e
noms qui est inaccessible depuis lextrieur de la fonction. Ainsi par exemple, si nous essayons
e
dacher le contenu de la variable u juste apr`s avoir eectu un appel ` la fonction fibonacci,
e
e
a
121
on obtient un message derreur (name u is not defined).

>>> fibonacci(9)
55
>>> u
Traceback ...
NameError: name u is not defined
Lespace de noms rserv lors de lappel de la fonction est automatiquement dtruit d`s que la
e
e
e
e
fonction a termin son travail (voir les appels quivalents en section 3.3.1).
e
e
Les variables dnies ` lextrieur dune fonction sont des variables globales . Leur valeur
e
a
e
est visible de lintrieur dune fonction, mais la fonction ne peut pas a priori la modier.
e
>>>
...
...
...
...
>>>
>>>
4
>>>
6
def f(x):
y = 3
x = x + y
return x
y = 6
f(1)
y
On constate que la variable y na pas

chang de valeur entre avant et
e
apr`s lappel ` la fonction f bien quil
e
a
semble quelle soit modie ` lintrieur
e a
e
de f (y = 3). En fait, il ne sagit pas
des mmes variables : lune est globale
e
(extrieur ` la fonction) et vaut 6, lautre
e
a
est locale (intrieur ` la fonction) et vaut
e
a
3.
Si deux variables portent le mme nom ` lextrieur et ` lintrieur dune fonction, la priorit est
e
a
e
a
e
e
donne ` la variable locale ` lintrieur de la fonction ; ` lextrieur de la fonction, le probl`me
e a
a
e
a
e
e
ne se pose pas : la variable locale nexiste pas.
TD3.8
3.3.4
Appels rcursifs
e
La suite des nombres un de Fibonacci est dnie par la relation de rcurrence suivante
e
e
(exemple 3.4 page 104) :
u0 = 1 , u1 = 1 , un = un1 + un2 n N, n > 1
La relation de rcurrence exprime le nombre un ` lordre n en fonction des nombres un1 et
e
a
un2 , respectivement ` lordre (n 1) et (n 2). Ainsi, on dnit un directement en fonction
a
e
de un1 et de un2 . Cette criture est tr`s compacte et tr`s expressive ; en particulier, elle
e
e
e
ne fait pas intervenir de boucle comme dans le code de la fonction dnie en section 3.2.6. Il
e
TD 3.8 : Portee des variables

On consid`re les fonctions f, g et h suivantes :
e
def h(x) :
def g(x) :
def f(x) :
x = 2*g(f(x))
x = 2*f(x)
x = 2*x
print(h, x)
print(g, x)
print(f, x)
return x
return x
return x
Quachent les appels suivants ?
1. >>>
>>>
?
>>>
>>>
?
>>>
>>>
?
>>>
>>>
?
x = 5
print(x)
y = f(x)
print(x)
z = g(x)
print(x)
t = h(x)
print(x)
2. >>>
>>>
?
>>>
>>>
?
>>>
>>>
?
>>>
>>>
?
x = 5
print(x)
x = f(x)
print(x)
x = g(x)
print(x)
x = h(x)
print(x)

122
serait donc intressant de dnir la fonction fibonacci de mani`re aussi simple dans le langage
e
e
e
algorithmique.
Version itrative :
e
def fibonacci(n) :
u, u1, u2 = 1, 1, 1
u = u1 + u2
u2 = u1
u1 = u
return u
Version rcursive :
e
def fibonacci(n) :
u = 1
if n > 1 :
u = fibonacci(n-1) + fibonacci(n-2)
return u
On retrouve ` gauche la version itrative dj` propose en section 3.2.6. A droite, la version
a
e
ea
e
est dite rcursive parce que dans le corps de la fonction fibonacci, on appelle la fonction
e
fibonacci elle-mme, et on lappelle mme 2 fois. Cette version rcursive est la traduction
e
e
e
directe de la formulation mathmatique.
e
Dnition 3.15 : fonction recursive

e
Une fonction est dite rcursive si elle sappelle elle-mme : on parle alors dappel rcursif de la
e
e
e
fonction.
Fig. 3.14 : Recursivite en arbre : fibonacci

>>> fibonacci(5)
8
fibonacci(5)
fibonacci(4)
fibonacci(3)
fibonacci(2)
fibonacci(1)
fibonacci(0)
fibonacci(1)
fibonacci(2)
fibonacci(1)
fibonacci(0)
fibonacci(3)
fibonacci(2)
fibonacci(1)
fibonacci(0)
fibonacci(1)
Dans la version rcursive, pour calculer fibonacci(5), on calcule dabord fibonacci(4)

e
et fibonacci(3). Pour calculer fibonacci(4), on calcule fibonacci(3) et fibonacci(2).
Pour calculer fibonacci(3), on calcule fibonacci(2) et fibonacci(1). . . Le droulement du
e
processus ressemble ainsi ` un arbre (gure 3.14). On remarque que les branches de larbre se
a
divise en deux ` chaque niveau (sauf en bas de larbre, ie ` droite sur la gure), ce qui traduit le
a
a
fait que la fonction fibonacci sappelle elle-mme deux fois ` chaque fois quelle est invoque
e
a
e
avec n > 1. Dans cet arbre, on constate par exemple que le calcul de fibonacci(3) est dvelopp
e
e
intgralement 2 fois : une fois pour le calul de fibonacci(4) et une fois pour lui-mme. En fait,
e
e
il nest pas tr`s dicile de montrer que le nombre de fois o` la fonction calcule fibonacci(1)
e
u
ou fibonacci(0) (ie. le nombre de feuilles dans larbre) est prcisment un (fibonacci(n)).
e e
Or la valeur de un cro de mani`re exponentielle avec n ; ainsi, avec cette version rcursive, le
t
e
e
processus de calcul de fibonacci(n) prend un temps qui cro de faon exponentielle avec n.
t
c
Dans la version itrative, on ne passe que (n 1) fois dans la boucle. Ainsi, le processus de
e
calcul itratif de fibonacci(n) prend un temps qui cro de mani`re linaire avec n. La dirence
e
t
e
e
e
entre les temps de calcul requis par les 2 mthodes, lune linaire en n et lautre augmentant
e
e
aussi vite que un lui-mme, est donc norme mme pour de petites valeurs de n. Par exemple,
e
e
e
pour n = 50, il faudra 50 units de temps pour la mthode itrative contre 20365011074 (plus de
e
e
e
123
20 milliards units de temps !) pour la mthode rcursive. La version itrative sera donc prfre
e
e
e
e
eee
a
` la version rcursive dans ce cas l` : il ny a pas photo !
e
a
Il ne faudrait pas conclure ` linutilit des processus rcursifs en arbre. Pour les processus
a
e
e
oprant sur des structures de donnes hirarchiques et non plus sur des nombres, la rcursivit
e
e
e
e
e
en arbre est un outil naturel et puissant1 . Mme pour les calculs numriques, les processus
e
e
rcursifs en arbre peuvent tre utiles a la comprhension et ` la conception dalgorithmes. Par
e
e
`
e
a
exemple, bien que la version rcursive de fibonacci soit beaucoup moins ecace que la version
e
itrative, elle sobtient presque directement, tant ` peine plus quune traduction en Python
e
e
a
de la dnition mathmatiques des nombres de Fibonacci. En revanche, pour formuler la version
e
e
itrative, il fallait avoir remarqu que le calcul pouvait tre revu sous la forme dune itration
e
e
e
e
avec 3 variables ; ce qui est bien moins direct et moins intuitif que la version rcursive.
e
Fig. 3.15 : Tours de Hano (1)
Etat initial :
dpart
On cherche donc ` dnir une procdure hanoi(n,depart,intermediaire,arrivee) qui devra

a e
e
dplacer n disques de la tour depart ` la tour arrivee en utilisant la tour intermediaire
e
a
comme tour de transit. Numrotons 1, 2, 3, . . . , n les n disques du plus petit (numro 1) au
e
e
plus grand (numro n). A un moment donn, dans la suite des oprations ` eectuer, il faue
e
e
a
dra dplacer le disque numro n (le plus grand, plac initialement en dessous de la pile de
e
e
e
disques) de la tour dpart ` la tour arrive . Pour pouvoir eectuer ce dplacement,
e
a
e
e
il faut dune part quil ny ait plus aucun disque sur le disque n et dautre part que la tour
arrive soit vide ; en consquence, il faut que tous les autres disques (de 1 ` (n 1))
e
e
a
soient sur la tour intermdiaire (gure 3.16 a). Pour atteindre cet tat intermdiaire, il faut
e
e
e
1
`
Ltude des structures de donnes arborescentes est aborde ` partir du 5eme semestre des enseignements
e
e
e a
dinformatique ` lENIB.
a
arrive
intermdiaire
arrive
Etat nal :
dpart
Exemple 3.5 : Tours de Hano
Les tours de Hano est un jeu imagin par le mathmaticien franais Edouard Lucas (1842
e
e
c
1891). Il consiste ` dplacer n disques de diam`tres dirents dune tour de dpart ` une
a e
e
e
e
a
tour d arrive en passant par une tour intermdiaire et ceci en un minimum de coups,
e
e
tout en respectant les r`gles suivantes :
e
on ne peut dplacer quun disque ` la fois,
e
a
on ne peut placer un disque que sur un autre disque plus grand que lui ou sur une tour
vide.
Dans ltat initial, les n disques sont placs sur la tour dpart . Dans ltat nal, tous les
e
e
e
e
disques se retrouvent placs dans le mme ordre sur la tour arrivee (gure 3.15). TD3.9
e
e
e
intermdiaire
TD 3.9 : Tours de Hano ` la main

a
Rsoudre ` la main le probl`me des tours de Hano ` n
e
a
e
a
disques (voir exemple 3.5 et gure 3.15) successivement
pour n = 1, n = 2, n = 3 et n = 4.
Fig. 3.16 : Tours de Hano (2)
Etat intermdiaire a :
e
dpart
intermdiaire
arrive
dplacer disque 3 de la tour

e
dpart ` la tour arrive
e
a
e
Etat intermdiaire b :
e
dpart
intermdiaire
arrive

124
Fig. 3.17 : Recursivite en arbre : hanoi

>>> hanoi(3,d,i,a)
hanoi(3,d,i,a)
hanoi(2,d,a,i)
hanoi(1,d,i,a)
hanoi(0,d,a,i)
deplacer(1,d,a)
hanoi(0,i,d,a)
deplacer(2,d,i)
hanoi(1,a,d,i)
hanoi(0,a,i,d)
deplacer(1,a,i)
hanoi(0,d,a,i)
deplacer(3,d,a)
hanoi(1,i,a,d)
hanoi(0,i,d,a)
hanoi(0,a,i,d)
deplacer(2,i,a)
hanoi(1,d,i,a)
hanoi(0,d,a,i)
deplacer(1,d,a)
hanoi(0,i,d,a)
def hanoi(n,gauche,milieu,droit):
assert n >= 0
if n > 0:
hanoi(n-1,gauche,droit,milieu)
deplacer(n,gauche,droit)
hanoi(n-1,milieu,droit,gauche)
return
>>> hanoi(3,d,i,a)
e
e
e
e
e
e
e
d
d
a
d
i
i
d
a
`
a
`
a
`
a
`
a
`
a
`
a
`
la
la
la
la
la
la
la
tour
tour
tour
tour
tour
tour
tour
a
i
i
a
d
a
a
hanoi(2,i,d,a)
deplacer(1,i,d)
donc dplacer les (n 1) premiers disques de la tour dpart ` la tour intermdiaire

e
e
a
e
en utilisant la tour arrive comme tour de transit : ce dplacement correspond ` lape
e
a
pel hanoi(n-1,depart,arrivee,intermediaire). Une fois ralis ce dplacement des (n 1)
e e
e
premiers disques, le disque n peut tre dplac de la tour dpart ` la tour arrive
e
e
e
e
a
e
(gure 3.16 b). Il ne reste plus qu` dplacer les (n 1) premiers disques de la tour ina e
termdiaire ` la tour arrive en utilisant la tour dpart comme tour de transit ; ces
e
a
e
e
derniers dplacements correspondent ` lappel hanoi(n-1,intermediaire,depart,arrivee).
e
a
On en dduit limplmentation de la procdure hanoi de la page suivante o` le dplacement y
e
e
e
u
e
est traduit par un simple achage du type : dplacer disque 3 de la tour dpart `
e
e
a
la tour arrive . Un appel de cette procdure pour n = 3 est donn ` titre dexemple ;
e
e
ea
les tours dpart , intermdiaire et arrive y sont respectivement nommes d, i
e
e
e
e
et a.
def deplacer(n,gauche,droit):
print(dplacer disque, n,
e
de la tour, gauche,
` la tour, droit)
a
return
Lexcution dun appel ` la procdure hanoi sapparente ici encore ` un processus rcursif en
e
a
e
a
e
arbre : les 7 dplacements eectus lors de lappel hanoi(3,d,i,a) sont numrots dans
e
e
e e
leur ordre dapparition sur la gure 3.17 (les appels ` la fonction hanoi pour n = 0 ne font rien).
a
Mais toutes les fonctions rcursives ne conduisent pas ncessairement ` un processus rcursif en
e
e
a
e
arbre comme lexemple de la fonction factorielle le montre.
Exemple 3.6 : Fonction factorielle

La fonction factorielle qui calcule le produit des n premiers entiers positifs (n! =
k) est
k=1
125
simplement dnie par la relation de rcurrence :

e
e
0! = 1
n! = n (n 1)! n N
Version itrative :
e
def factorielle(n) :
u = 1
u = u * i
return u
Version rcursive :
e
def factorielle(n) :
u = 1
if n > 1 :
u = n * factorielle(n-1)
return u
On retrouve ` gauche la version itrative bien connue. A droite, la version rcursive est la traa
e
e
duction directe de la formulation mathmatique. Dans la version rcursive, le processus ncessite
e
e
e
que linterprteur garde une trace des multiplications ` raliser plus tard (gure 3.18). Le proe
a e
cessus cro puis dcro : la croissance se produit lorsque le processus construit une cha
t
e t
ne
doprations dires (ici, une cha de multiplications dires) et la dcroissance intervient
e
ee
ne
ee
e
lorsquon peut valuer les multiplications. Ainsi, la quantit dinformation quil faut mmoriser
e
e
e
pour eectuer plus tard les oprations dires cro linairement avec n : on parle de processus
e
ee
t e
rcursif linaire. Linterprtation dune fonction rcursive passe donc par une phase dexpansion
e
e
e
e
dans lesquels les appels rcursifs sont empils jusqu` arriver ` un appel de la fonction pour
e
e
a
a
lequel une condition darrt sera vrie, puis par une phase de contraction dans laquelle les
e
e e
rsultats des appels prcdemment empils sont utiliss. Par contre, dans la version itrative,
e
e e
e
e
e
le processus de calcul ne cro ni ne dcro : ` chaque tape, seules les valeurs courantes des
t
e t a
e
variables u et i sont ncessaires (il ny a pas doprations dires) et le temps requis pour
e
e
ee
calculer n! augmente linairement avec n (on passe n 2 fois dans la boucle).
e
TD3.10
Lorsquon parle de fonction rcursive, on fait rfrence ` une caractristique syntaxique :
e
ee
a
e
la fonction, dans sa propre dnition, se fait rf`rence ` elle-mme (elle sappelle elle-mme).
e
ee
a
e
e
Mais lorsquon parle de processus rcursif, linaire ou en arbre, on sintresse au droulement
e
e
e
e
du processus, et non ` la syntaxe de lcriture de la fonction. Ainsi, une fonction peut avoir une
a
e
dnition rcursive mais correspondre ` un processus itratif : cest le cas de la nouvelle version
e
e
a
e
de la fonction factorielle ci-dessous.
Fig. 3.18 : Recursivite lineaire : factorielle

factorielle(5)
(5*factorielle(4))
(5*(4*factorielle(3)))
(5*(4*(3*factorielle(2))))
(5*(4*(3*(2*factorielle(1)))))
(5*(4*(3*(2*1))))
(5*(4*(3*2)))
(5*(4*6))
(5*24)
120
TD 3.10 : Pgcd et ppcm de 2 entiers (1)

1. Dnir une fonction rcursive qui calcule le plus
e
e
grand commun diviseur d de 2 entiers a et b :
pgcd(a, b) = pgcd(b, a mod b) = . . .
. . . = pgcd(d, 0) = d.
2. En dduire une fonction qui calcule le plus petit
e
commun multiple m de 2 entiers a et b.

126
def factorielle(n):
u = factIter(n,1,1)
return u
def factIter(n,i,fact):
u = fact
if i < n:
u = factIter(n,i+1,fact*(i+1))
return u
TD 3.11 : Somme arithmetique

1. Dnir une fonction rcursive qui calcule la
e
e
somme des n premiers nombres entiers.
s=
n
X
k=0
k=
n(n + 1)
2
2. Comparer la complexit de cette version avec les

e
versions constante et itrative (voir TD 3.5).
e
TD 3.12 : Courbes fractales
On sintresse ici aux programmes dont lexcution proe
e
duit des dessins ` laide de la tortue Logo (voir ana
nexe 3.5.1 page 152). On consid`re la procdure draw
e
e
ci-dessous :
def draw(n,d) :
assert n >= 0
if n == 0 : forward(d)
else :
draw(n-1,d/3.)
left(60)
draw(n-1,d/3.)
right(120)
draw(n-1,d/3.)
left(60)
draw(n-1,d/3.)
return
Dessiner le rsultat des appels draw(n,900) respectivee
ment pour n = 0, n = 1, n = 2 et n = 3. A chaque appel, le crayon est initialement en (0, 0) avec une direction
de 0.
factorielle(5)
(factIter(5,1,1))
(factIter(5,2,2))
(factIter(5,3,6))
(factIter(5,4,24))
(factIter(5,5,120))
120
La nouvelle fonction factorielle appelle une fonction auxiliaire factIter dont la dnition
e
est syntaxiquement rcursive (factIter sappelle elle-mme). Cette fonction ` 3 arguments :
e
e
a
lentier n dont il faut calculer la factorielle, un compteur i initialis ` 1 au premier appel de
e a
factIter par factorielle et incrment ` chaque nouvel appel, et un nombre fact initialis
e
ea
e
a
` 1 et multipli par la nouvelle valeur du compteur ` chaque nouvel appel. Le droulement
e
a
e
dun appel ` factIter montre quainsi, ` chaque tape, la relation (i ! == fact) est toujours
a
a
e
vrie. La fonction factIter arrte de sappeler elle-mme lorsque (i == n) et on a alors
e e
e
e
(fact == i ! == n !) qui est la valeur recherche. Ainsi, ` chaque tape, nous navons besoin
e
a
e
que des valeurs courantes du compteur i et du produit fact, exactement comme dans la version
itrative de la fonction factorielle : il ny a plus de cha doprations dires comme dans
e
ne
e
ee
la version rcursive de factorielle. Le processus mis en jeu ici est un processus itratif, bien
e
e
que la dnition de factIter soit rcursive.
e
e
TD3.11
Dans la fonction factIter, le rsultat de lappel rcursif est retourn par la fonction : on
e
e
e
parle alors de rcursivit terminale (ou rcursivit ` droite). Lexcution dun tel appel termine
e
e
e
ea
e
lexcution de la fonction.
e
Dnition 3.16 : recursivite terminale

e
Un appel rcursif terminal est un appel rcursif dont le rsultat est celui retourn par la fonction.
e
e
e
e
En dautres termes, si dans le corps dune fonction, un appel rcursif est plac de telle faon
e
e
c
que son excution nest jamais suivi par lexcution dune autre instruction de la fonction, cet
e
e
appel est dit rcursif ` droite.
e
a
Dnition 3.17 : recursivite non terminale

e
Un appel rcursif non terminal est un appel rcursif dont le rsultat nest pas celui retourn par
e
e
e
e
la fonction.
TD3.12
127
Quel que soit le probl`me ` rsoudre, on a le choix entre lcriture dune fonction itrative et
e
a e
e
e
celle dune fonction rcursive. Si le probl`me admet une dcomposition rcurrente naturelle, le
e
e
e
e
programme rcursif est alors une simple adaptation de la dcomposition choisie. Cest le cas des
e
e
fonctions factorielle et fibonacci par exemple. Lapproche rcursive prsente cependant des
e
e
inconvnients : certains langages nadmettent pas la rcursivit (comme le langage machine !)
e
e
e
et elle est souvent coteuse en mmoire comme en temps dexcution. On peut pallier ces inu
e
e
convnients en transformant la fonction rcursive en fonction itrative : cest toujours possible.
e
e
e
Considrons une procdure f ` rcursivit terminale crite en pseudo-code :
e
e
a e
e
e
def f(x):
if cond: arret
else:
instructions
f(g(x))
return
x reprsente ici la liste des arguments de la fonction, cond une

e
condition portant sur x, instructions un bloc dinstructions
qui constituent le traitement de base de la fonction f, g(x) une
transformation des arguments et arret linstruction de terminaison (clause darrt) de la rcurrence.
e
e
Elle est quivalente ` la procdure itrative suivante :

e
a
e
e
def f(x):
while not cond:
instructions
x = g(x)
arret
return
Illustrons cette transformation ` laide de la fonction qui calcule le pgcd de 2 entiers.

a
def pgcd(a,b):
if b == 0: return a
else:
pass # ne fait rien
return pgcd(b,a%b)
>>> pgcd(12,18)
6
x
cond
arret
instructions
x = g(x)
a,b
b == 0
return a
pass
a,b = b,a%b
def pgcd(a,b):
while not (b == 0):
pass
a,b = b,a%b
return a
>>> pgcd(12,18)
6
La mthode prcdente ne sapplique qu` la rcursivit terminale. Une mthode gnrale

e
e e
a
e
e
e
e e
existe pour transformer une fonction rcursive quelconque en une fonction itrative quivalente.
e
e
e
En particulier, elle est mise en uvre dans les compilateurs car le langage machine nadmet pas
la rcursivit. Cette mthode gnrale fait appel ` la notion de pile (section 4.2.4 page 167) pour
e
e
e
e e
a
sauvegarder le contexte des appels rcursifs. On lillustrera dans le cas particulier du tri dune
e
liste par la mthode du tri rapide (section 4.4.3 page 177).
e

128
3.4
3.4.1
e
Conna
tre
TD 3.13 : QCM (3)

1. La rutilisabilit dun algorithme est son aptitude
e
e
(a) ` utiliser de mani`re optimale les ressources du matriel qui lexcute
a
e
e
e
(b) ` se protger de conditions anormales dutilisation
a
e
(c) ` rsoudre des tches quivalentes ` celle pour laquelle il a t conu
a e
a
e
a
ee
c
(d) ` raliser exactement la tche pour laquelle il a t conu
a e
a
ee
c
2. Lencapsulation est laction
(a) de mettre une chose dans une autre
(b) de fermer une chose par une autre
(c) de substituer une chose par une autre
(d) de remplacer une chose par une autre
3. Une fonction est un bloc dinstructions nomm et paramtr
e
e e
(a) qui ne peut pas retourner plusieurs valeurs
(b) qui ne peut pas contenir dinstructions itratives
e
(c) qui retourne une valeur
(d) qui ne retourne pas de valeur
4. Les param`tres dentre dune fonction sont
e
e
(a) les arguments ncessaires pour eectuer le traitement associ ` la fonction
e
ea
(b) les valeurs obtenues apr`s avoir eectu le traitement associ ` la fonction
e
e
ea
(c) des grandeurs invariantes pendant lexcution de la fonction
e
(d) des variables auxiliaires dnies dans le corps de la fonction
e
5. Les prconditions dune fonction sont des conditions ` respecter
e
a
(a) par les param`tres de sortie de la fonction
e

129
(b) pendant toute lexcution de la fonction

e
(c) par les param`tres dentre de la fonction
e
e
(d) pour pouvoir compiler la fonction
6. La description dune fonction dcrit
e
(a) ce que fait la fonction
(b) comment fait la fonction
(c) pourquoi la fonction le fait
(d) o` la fonction le fait
u
7. Le jeu de tests dune fonction est
(a) un ensemble dexercices ` rsoudre
a e
(b) un ensemble dexceptions dans le fonctionnement de la fonction
(c) un ensemble caractristiques dentres-sorties associes
e
e
e
(d) un ensemble de recommandations dans lutilisation de la fonction
8. En Python, linstruction assert permet de
(a) tester une prcondition
e
(b) imposer une instruction
(c) paramtrer une fonction
e
(d) tester un test du jeu de tests
9. La validit dune fonction est son aptitude ` raliser exactement la tche pour laquelle elle
e
a e
a
a t conue. Plus concr`tement,
ee
c
e
(a) la fonction doit vrier imprativement ses prconditions
e
e
e
(b) la fonction doit tre correctement paramtre
e
e e
(c) limplmentation de la fonction doit tre conforme aux jeux de tests
e
e
(d) lutilisation de la fonction doit tre conviviale
e
10. Le passage des param`tres par valeur consiste ` copier
e
a
(a) la valeur du param`tre formel dans le param`tre eectif correspondant
e
e
(b) la rfrence du param`tre eectif dans le param`tre formel correspondant
ee
e
e

130
(c) la rfrence du param`tre formel dans le param`tre eectif correspondant

ee
e
e
(d) la valeur du param`tre eectif dans le param`tre formel correspondant
e
e
11. Un appel rcursif est un appel
e
(a) dont lexcution est un processus rcursif
e
e
(b) dont lexcution est un processus itratif
e
e
(c) dont le rsultat est retourn par la fonction
e
e
(d) dune fonction par elle-mme
e
3.4.2
Comprendre
`
TD 3.14 : Passage des parametres
e
def f(x):
y = x + 2
return y
def g(z):
v = 2*f(z)
return v
def h(a):
b = g(f(a))
return b
Quels sont les algorithmes quivalents (algorithmes o` il ny a plus dappels aux fonctions f,
e
u
g et h) aux appels suivants :
1. u = f(2)
3. u = g(2)
5. u = h(2)
2. u = f(t)
4. u = g(t)
6. u = h(t)
TD 3.15 : Portee des variables (2)

e
def f(x):
x = x + 2
print(f, x)
return x
def g(x):
x = 2*f(x)
print(g, x)
return x
def h(x):
x = g(f(x))
print(h, x)
return x

131

1. >>> x = 5
4. >>> x = 5
>>> print(x)
>>> print(x)
>>> x = x + 2
>>> print(x)
>>> f(x)
>>> print(x)
>>> x = 2 * (x + 2)
>>> print(x)
2. >>> x = 5
>>> g(x)
>>> print(x)
>>> print(x)
>>> h(x)
>>> y = f(x)
>>> print(x, y)
>>> print(x)
>>> z = 2*f(y)
>>> print(x, y, z)
3. >>> x = 5
>>> print(x)
>>> z = 2*f(f(x))
>>> print(x, z)
3.4.3
Appliquer

TD 3.16 : Suite geometrique
Dnir une fonction rcursive qui calcule la somme des n premiers termes dune suite gomtrique
e
e
e e
uk = abk .
`
TD 3.17 : Puissance entiere
Dnir une fonction rcursive qui calcule la puissance enti`re p = xn dun nombre entier x.
e
e
e
TD 3.18 : Coefficients du binome

Dnir une fonction rcursive qui calcule les coecients du binme (a+b)n =
e
e
o
n
k=0
n!
ank bk .
k!(n k)!

132
TD 3.19 : Fonction dAckerman

Dnir une fonction rcursive qui calcule la fonction dAckerman :
e
e
f (0, n) = n + 1
f (m, 0) = f (m 1, 1) si m > 0
f : N2 N
f (m, n) = f (m 1, f (m, n 1)) si m > 0, n > 0
3.4.4
Analyser
TD 3.20 : Addition binaire

Dnir une fonction add2 qui eectue laddition binaire de 2 entiers a et b (le nombre de bits
e
nest pas limit a priori).
e
Exemple : (0101)2 + (10011)2 = (11000)2
# add2(a,b)
>>> add2([1,0],[1,0,1,1])
[1, 1, 0, 1]
>>> add2([1,0,1,1],[1,0])
[1, 1, 0, 1]
>>> add2([1,1],[1,1])
[1, 1, 0]
`
TD 3.21 : Complement a 2
Dnir une fonction neg2 qui dtermine le complment ` 2 en binaire dun entier n cod sur k
e
e
e
a
e
bits.
(011100)2 (100100)2 :
(011100)2
(100011)2
+ (000001)2
= (100100)2

133
# neg2(code)
>>> neg2([0,0,0,1,0,1,1,1])
[1, 1, 1, 0, 1, 0, 0, 1]
>>> neg2([1, 1, 1, 0, 1, 0, 0, 1])
[0, 0, 0, 1, 0, 1, 1, 1]
>>> for a in [0,1]:
...
for b in [0,1]:
...
for c in [0,1]:
...
add2([a,b,c],neg2([a,b,c]))
[0, 0, 0]
[1, 0, 0, 0]
[1, 0, 0, 0]
[1, 0, 0, 0]
[1, 0, 0, 0]
[1, 0, 0, 0]
[1, 0, 0, 0]
[1, 0, 0, 0]
1. Dnir une fonction ieee qui code un nombre rel x selon la norme IEEE 754 simple
e
e
prcision.
e
s
x = (1) (1 + m) 2
# ieee(x)
>>> ieee(0.0)
[0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
>>> ieee(0.625)
[0, 0, 1, 1, 1, 1, 1, 1, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
>>> ieee(3.1399998664855957)
[0, 1, 0, 0, 0, 0, 0, 0, 0,
1, 0, 0, 1, 0, 0, 0, 1, 1, 1,
0, 1, 0, 1, 1, 1, 0, 0, 0, 0,
>>> ieee(-4573.5)
[1, 1, 0, 0, 0, 1, 0, 1, 1,
0, 0, 0, 1, 1, 1, 0, 1, 1, 1,
1, 1, 0, 0, 0, 0, 0, 0, 0, 0,
0,
0, 0]
0,
0, 0]
1,
1, 0]
0,
0, 0]
(e127)
IEEE : www.ieee.org
Institute of Electrical and Electronics Engineers
TD 3.22 : Codage-decodage des reels

Remarque 3.6 : On pourra vrier les rsultats obtee
e
nus avec la fonction ieee du TD 3.22 ci-contre sur le site
http://babbage.cs.qc.edu/IEEE-754/Decimal.html

134
2. Dnir une fonction real qui dcode un nombre rel x cod selon la norme IEEE 754
e
e
e
e
simple prcision.
e
x = (1)s (1 + m) 2(e127)
# real(code)
>>> real(ieee(0.625))
0.625
>>> real(ieee(3.1399998664855957))
3.1399998664855957
>>> real(ieee(-4573.5))
-4573.5
TD 3.23 : Integration numerique

Soit f (x) une fonction continue de R R ` intgrer sur [a, b] (on supposera que f ` toutes les
a
e
a
bonnes proprits mathmatiques pour tre intgrable sur lintervalle considr). On cherche `
ee
e
e
e
e e
a
b
calculer son intgrale I =

e
f (x)dx qui reprsente classiquement laire comprise entre la courbe

e
a
reprsentative de f et les droites dquations x = a, x = b et y = 0. Les mthodes dintgration

e
e
e
e
numrique (mthode des rectangles, mthode des trap`zes et mthode de Simpson) consistent
e
e
e
e
e
essentiellement ` trouver une bonne approximation de cette aire.
a
f(x)
f(x)
f(a)
f(b)
0
f(x)
f(a)
f(b)
a
b
rectangles
f(a)
f(b)
a
b
trapzes
Simpson
On testera ces direntes mthodes avec la fonction f (x) = sin(x) sur [0, ].
e
e
1. Mthode des rectangles : subdivisons lintervalle dintgration de longueur ba en n parties
e
e
ba
gales de longueur x =
e
. Soient x1 , x2 , . . ., xn les points milieux de ces n intervalles.
n
Les n rectangles forms avec les ordonnes correspondantes ont pour surface f (x1 )x,
e
e
f (x2 )x, . . ., f (xn )x. Laire sous la courbe est alors assimile ` la somme des aires de
e a

135
ces rectangles, soit

b
f (x)dx (f (x1 ) + f (x2 ) + + f (xn )) x
I=
a
Cest la formule dite des rectangles qui repose sur une approximation par une fonction en
escalier.
e
e
Ecrire une fonction rectangle integration qui calcule lintgrale dnie I dune fonction
f sur [a, b] ` lordre n par la mthode des rectangles.
a
e
2. Mthode des trap`zes : subdivisons lintervalle dintgration de longueur b a en n parties
e
e
e
ba
gales de longueur x =
e
. Les abscisses des points ainsi dnis sont a, x1 , x2 ,
e
n
. . ., xn1 , b et les trap`zes construits sur ces points et les ordonnes correspondantes ont
e
e
x
x
x
pour aire
(f (a) + f (x1 )),
(f (x1 ) + f (x2 )), . . .,
(f (xn1 ) + f (b)). Laire sous
2
2
2
la courbe est alors assimile ` la somme des aires de ces trap`zes, soit
e a
e
b
f (x)dx
I=
a
f (a) + f (b)
+ f (x1 ) + f (x2 ) + + f (xn1 ) x
2
Cest la formule dite des trap`zes.

e
Ecrire une fonction trapezoid integration qui calcule lintgrale dnie I dune fonction
e
e
f sur [a, b] ` lordre n par la mthode des trap`zes.
a
e
e
3. Mthode de Simpson : divisons lintervalle dintgration [a, b] en un nombre n pair dine
e
ba
. Dans les 2 premiers intervalles dextrmits
e e
tervalles dont la longueur est x =
n
a, x1 et x2 , on approche la courbe reprsentative de f par une parabole dquation y =
e
e
x2 + x + passant par les points A(a, f (a)), A1 (x1 , f (x1 )) et A2 (x2 , f (x2 )) de la courbe.
Dans les 2 intervalles suivants, on approche la courbe par une autre parabole dquation
e
similaire, passant par les points A2 , A3 et A4 , et ainsi de suite. On obtient ainsi une courbe
forme de n portions de parabole et laire dtermine par ces portions de parabole est une
e
e
e
approximation de laire I cherche.
e
Lintgration de lquation de la parabole y = x2 + x + sur [x, x] donne
e
e
x
S=
2
(x2 + x + )dx = (x)3 + 2(x)
3
x

136
o` les constantes et sont dtermines en crivant que les points (x, y0 ), (0, y1 ) et
u
e
e
e
(x, y2 ) satisfont lquation de la parabole. On obtient ainsi :
e
(x)2
y0 =
+ (x) +
y1 =
y2 = (x)2 + (x) +
et S =
y0 2y1 + y2
2(x)2
y2 y0
=
2(x)
= y1
x
(y0 + 4y1 + y2 ).
3
x
(y0 + 4y1 + y2 )
3
x
S2 =
(y2 + 4y3 + y4 )
3
x
Par suite, il vient : S3 =
(y4 + 4y5 + y6 )
3
.
.
.
=
x
(yn2 + 4yn1 + yn )
Sn/2 =
3
do`
u
n1
b
x
I=
f (xi ) + 2
f (a) + 4
f (x)dx
3
a
S1
i=1,3,5...
n2
f (xi ) + f (b)
i=2,4,6...
Cest la formule dite de Simpson qui repose sur une approximation de f par des arcs de
parabole.
Ecrire une fonction simpson integration qui calcule lintgrale dnie I dune fonction
e
e
f sur [a, b] ` lordre n par la mthode de Simpson.
a
e

TD 3.24 : Traces de courbes parametrees
Une courbe paramtre dans le plan est une courbe o` labscisse x et lordonne y sont des
e e
u
e
fonctions dun param`tre qui peut tre le temps t ou un angle par exemple. La courbe se
e
e
prsente donc sous la forme x = f (t), y = g(t). Les tableaux ci-dessous en donnent quelques
e
exemples.

droite
cercle
ellipse
hyperbole
x = x0 + t
y = y0 + t
x = x0 + r cos()
y = y0 + r sin()
x = x0 + a cos()
y = y0 + b cos()
a
x = x0 +
cos()
y = y0 + b tan()
137
x = x0 + r( sin())
y = y0 + r(1 cos())
cyclo
de
picyclo
e
de
hypercyclo
de
limaon de Pascal
c
spirale logarithmique
R+r
r
R+r
y = y0 + (R + r) sin() r sin
r
Rr
x = x0 + (R r) cos() + r cos
r
Rr
x = y0 + (R r) sin() + r sin
r
x = x0 + (R + r) cos() r cos
x = x0 + (a cos() + b) cos()
y = y0 + (a cos() + b) sin()
x = x0 + ke cos()
y = y0 + ke sin()
Ecrire une fonction drawCurve qui permettent le trac de telles courbes paramtres (gure
e
e e
3.19). On utilisera les instructions ` la Logo pour raliser ces tracs (voir annexe 3.5.1 page
a
e
e
152).
3.4.5
TD 3.13 : QCM (3).

Les bonnes rponses sont extraites directement de ce document.
e
1c, 2a, 3c, 4a, 5c, 6a, 7c, 8a, 9c, 10d, 11d
TD 3.14 : Passage des param`tres.
e

Fig. 3.19 : Courbes parametrees

138
1. u = f(t)
x =
y =
tmp
del
u =
del
t
x + 2
= y
x, y
tmp
tmp
2. u = g(t)
z =
x =
y =
tmp
del
v =
tmp
del
u =
del
t
z
x + 2
= y
x, y
2*tmp
= v
v, z
tmp
tmp
TD 3.15 : Porte des variables (2).

e
1. >>> x = 5
>>>
5
>>>
>>>
7
>>>
>>>
18
x
x = x + 2
x
x = 2*(x+2)
x
3. u = h(t)
a =
x =
y =
tmp
del
z =
del
x =
y =
tmp
del
v =
tmp
del
b =
del
tmp
del
u =
del
t
a
x + 2
= y
x, y
tmp
tmp
z
x + 2
= y
x, y
2*tmp
= v
v, z
tmp
tmp
= b
a, b
tmp
tmp

2. >>> x = 5
3.
>>>
5
>>>
f 7
>>>
(5,
>>>
f 9
>>>
(5,
>>>
>>>
5
>>>
f 7
f 9
>>>
(5,
4. >>> x = 5
>>> x
5
>>> f(x)
f 7
7
>>> x
5
>>> g(x)
f 7
g 14
14
>>> x
5
>>> h(x)
f 7
f 9
g 18
h 18
18
>>> x
5
y = f(x)
x, y
7)
z = 2*f(y)
x, y, z
7, 18)
x = 5
x
z = 2*f(f(x))
x, z
18)
TD 3.16 : Suite gomtrique.

e e
n
a bk = a
s=
k=0
139
TD 3.17 : Puissance enti`re.

e
bn+1 1
b1
def sommeGeometrique(a,b,n):
"""
s = sommeGeometrique(a,b,n)
est la somme des n premiers termes dune suite
gomtrique a*b^k (k in [0,n])
e e
"""
assert type(n) is int and n >= 0
if n == 0: s = 1
else: s = sommeGeometrique(a,b,n-1) + (a * b**n)
return s
p = xn
def puissance(x,n):
""""
y = puissance(x,n)
est la puissance enti`re de x de degr n
e
e
"""
if n == 0: p = 1
else: p = x*puissance(x,n-1)
return p

140
TD 3.18 : Coecients du binme.
o
(a + b)n =
k=0
n!
xnk y k
k!(n k)!
def coefficientBinome(n,p):
"""
c = coefficientBinome(n,p)
est le p-i`me coefficient du bin^me (a+b)**n
e
o
"""
assert type(n) is int and type(p) is int
assert n >= 0 and p >= 0 and p <= n
if p == 0 or n == 0 or n == p: c = 1
else: c = coefficientBinome(n-1,p) + coefficientBinome(n-1,p-1)
return c
TD 3.19 : Fonction dAckerman.
f (0, n) = n + 1
f (m, 0) = f (m 1, 1) si m > 0
f : N2 N
f (m, n) = f (m 1, f (m, n 1)) si m > 0, n > 0
def ackerman(m,n):
"""
y = ackerman(m,n)
"""
assert type(n) is int and type(m) is int
assert n >= 0 and m >= 0
if m == 0: a = n + 1
elif: n == 0: a = ackerman(m-1,1)
else: a = ackerman(m-1,ackerman(m,n-1))
return a

TD 3.20 : Addition binaire.
141
TD 3.21 : Complment ` 2.
e
a
def add2(code1,code2):
"""
sum2 = add2(code1,code2)
additionn binaire sum2 = code1 + code2
>>> add2([1,0,1],[1])
[1, 1, 0]
>>> add2([1,0,1],[1,0])
[1, 1, 1]
>>> add2([1,0],[1,0,1])
[1, 1, 1]
>>> add2([1,0,1],[1,1])
[1, 0, 0, 0]
"""
assert type(code1) is list
sum2 = []
diffLen = len(code1) - len(code2)
if diffLen > 0:
for i in range(diffLen): insert(code2,0,0)
else:
for i in range(-diffLen): insert(code1,0,0)
for i in range(len(code1)): append(sum2,0)
carry = 0
for i in range(len(code1)-1,-1,-1):
value = code1[i] + code2[i] + carry
if value >= 2:
sum2[i] = value - 2
carry = 1
else:
sum2[i] = value
carry = 0
def neg2(code):
"""
neg = neg2(code)
complment ` 2 dun entier binaire
e
a
>>>
[1,
>>>
[0,
neg2([0,0,0,1,0,1,1,1])
1, 1, 0, 1, 0, 0, 1]
neg2([1, 1, 1, 0, 1, 0, 0, 1])
0, 0, 1, 0, 1, 1, 1]
>>>
...
...
...
[0,
[1,
[1,
[1,
[1,
[1,
[1,
[1,
"""
for a in [0,1]:
for b in [0,1]:
for c in [0,1]:
add2([a,b,c],neg2([a,b,c]))
0, 0]
0, 0, 0]
0, 0, 0]
0, 0, 0]
0, 0, 0]
0, 0, 0]
0, 0, 0]
0, 0, 0]
assert type(code) is list

neg = []
if carry == 1: insert(sum2,0,1)
carry = 1
for i in range(len(code)): append(neg,int(not code[i]))
value = neg[len(code)-1-i] + carry
if value >= 2:
neg[len(code)-1-i] = value - 2
carry = 1
else:
neg[len(code)-1-i] = value
carry = 0
return sum2
return neg

142
TD 3.22 : Codage-dcodage des rels.
e
e
def ieee(x):
"""
ieee_code = ieee(x)
code le rel x selon la norme IEEE 754 simple prcision
e
e
>>> ieee(0.0)
[0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
>>> ieee(0.625)
[0,
0, 1, 1, 1, 1, 1, 1, 0,
0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
>>> ieee(3.1399998664855957)
[0,
1, 0, 0, 0, 0, 0, 0, 0,
1, 0, 0, 1, 0, 0, 0, 1, 1, 1,
>>> ieee(-4573.5)
[1,
1, 0, 0, 0, 1, 0, 1, 1,
0, 0, 0, 1, 1, 1, 0, 1, 1, 1,
"""
assert type(x) is float
ieee_code = []
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0]
0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
k_exponent = 8
k_significand = 23
k_ieee = 32
bias = code(127,2,k_exponent)
x_int = int(abs(x))
x_frac = abs(x) - x_int
expo_2 = 0
for i in range(k_ieee): ieee_code.append(0)

# calcul du signe
sign = int(x < 0)
# calcul de la mantisse
i = 0
significand = []
while (x_int != 0) and (i < k_significand):
significand.insert(0,x_int%2)
x_int = x_int/2
i = i + 1
if len(significand) > 0 and
significand[0] == 1:
del significand[0]
expo_2 = len(significand)
i = len(significand)
while (x_frac != 0) and (i < k_significand):
x_frac = x_frac * 2
x_int = int(x_frac)
x_frac = x_frac - x_int
if (x_int == 0) and (i == 0):
expo_2 = expo_2 - 1
else:
significand.append(x_int)
i = i + 1
if abs(x) < 1 and len(significand) > 0 and
significand[0] == 1:
del significand[0]
expo_2 = expo_2 - 1
for i in range(len(significand),k_significand):
significand.append(0)
# calcul de lexposant
exponent = code(abs(expo_2),2,k_exponent)
if expo_2 >= 0: exponent = add2(bias,exponent)
elif expo_2 < 0: exponent = sub2(bias,exponent)
143
# calcul du code IEEE 754 simple prcision
e
if x == 0.0:
ieee_code = []
for i in range(k_ieee): ieee_code.append(0)
else:
ieee_code[0] = sign
ieee_code[1:9] = exponent
ieee_code[9:32] = significand
return ieee_code
#----------------------------------------------def sub2(code1,code2):
"""
substract = sub2(code1,code2)
soustraction binaire substract = code1 - code2
"""
assert len(code1) == len(code2)
substract = []
for i in range(len(code1)): append(substract,0)
carry = 0
for i in range(len(code1)-1,-1,-1):
if code1[i] < (code2[i] + carry):
substract[i] = code1[i] + 2 - (code2[i] + carry)
carry = 1
else:
substract[i] = code1[i] - (code2[i] + carry)
carry = 0
return substract

144
TD 3.23 Intgration numrique.
e
e
1. Mthode des rectangles.
e
b
f (x)dx (f (x1 ) + f (x2 ) + + f (xn )) x
I=
a
Intgration : mthode des rectangles

e
e
1
2
3
4
def rec tang le_in tegr ation (f , x1 , x2 , n ):

"""
int gration de f ( x ) entre x1 et x2
e
par la m thode des n rectangles
e
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> fabs ( rec tang le_in te g r a t i o n ( sin ,0. ,2* pi ,100000)) < 1. e -6
True
>>> fabs ( rec tang le_in te g r a t i o n ( sin ,0. , pi ,100000) - 2.) < 1. e -6
True
>>> fabs ( rec tang le_in te g r a t i o n ( sin ,0. , pi /2 ,100000) - 1) < 1. e -6
True
>>> fabs ( rec tang le_in te g r a t i o n ( cos ,0. , pi ,100000)) < 1. e -6
True
>>> fabs ( rec tang le_in te g r a t i o n ( cos , - pi /2 , pi /2 ,100000) - 2) < 1. e -6
True
"""
assert type ( x1 ) is float
assert x1 <= x2
20
21
22
23
24
25
26
27
28
integral = 0.0
width = ( x2 - x1 )/ n
x = x1 + width /2
while x < x2 :
integral = integral + f ( x )
x = x + width
integral = integral * width
return integral

145
2. Mthode des trap`zes.

e
e
b
f (x)dx
I=
a
f (a) + f (b)
+ f (x1 ) + f (x2 ) + + f (xn1 ) x
2
Intgration : mthode des trap`zes

e
e
e
1
def tra pezo id_in tegr at io n (f , x1 , x2 , n ):
2
3
4
5
"""
e
par la m thode des n trap` zes
e
e
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
>>> fabs ( tra pezo id_in tegr ation ( sin ,0. ,2* pi ,100000)) < 1. e -6
True
>>> fabs ( tra pezo id_in tegr ation ( sin ,0. , pi ,100000) - 2.) < 1. e -6
True
>>> fabs ( tra pezo id_in tegr ation ( sin ,0. , pi /2 ,100000) - 1) < 1. e -6
True
>>> fabs ( tra pezo id_in tegr ation ( cos ,0. , pi ,100000)) < 1. e -6
True
>>> fabs ( tra pezo id_in tegr ation ( cos , - pi /2 , pi /2 ,100000) - 2) < 1. e -6
True
"""
assert type ( n ) is int
assert x1 <= x2
22
23
24
25
26
27
28
29
30
integral = ( f ( x1 ) + f ( x2 ))/2
width = ( x2 - x1 )/ n
x = x1 + width
while x < x2 :
integral = integral + f ( x )
x = x + width
integral = integral * width
return integral

146
3. Mthode de Simpson.
e
f (x)dx
I=
a
x
f (a) + 4
3
n1
n2
f (xi ) + 2
i=1,3,5...
f (xi ) + f (b)
i=2,4,6...
Intgration : mthode de Simpson

e
e
1
2
3
4
def simpson_integration (f , x1 , x2 , n ):
"""
e
par la m thode de Simpson
e
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
>>> fabs ( simpson_integra t i on ( sin ,0. ,2* pi ,100000)) < 1. e -6

True
>>> fabs ( simpson_integra t i on ( sin ,0. , pi ,100000) - 2.) < 1. e -6
True
>>> fabs ( simpson_integra t i on ( sin ,0. , pi /2 ,100000) - 1) < 1. e -6
True
>>> fabs ( simpson_integra t i on ( cos ,0. , pi ,100000)) < 1. e -6
True
>>> fabs ( simpson_integra t i on ( cos , - pi /2 , pi /2 ,100000) - 2) < 1. e -6
True
"""
assert x1 <= x2
assert n %2 == 0
22
23
24
25
26
27
28
29
30
integral = f ( x1 ) + f ( x2 )
width = ( x2 - x1 )/ n
for i in range (1 ,n ,2):
integral = integral + 4* f ( x1 + i * width )
for i in range (2 ,n ,2):
integral = integral + 2* f ( x1 + i * width )
integral = integral * width /3
return integral

147
TD 3.24 Tracs de courbes paramtres.

e
e e
1
2
3
4
def drawCurve (( fx , fy ) , t1 , t2 , dt ):
"""
trace une courbe param tr e pour t dans [ t1 , t2 ] par pas de dt
e e
pour les fonctions x = fx ( t ) et y = fy ( t )
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> drawCurve ( parametric_line (10 , -10 ,2 ,3) , -20. ,20. ,0.1)

>>> drawCurve ( parametric_circle (10 , -20 ,40) ,0. ,2* pi , pi /100)
>>> drawCurve ( parametric_ellipse ( -30. , -10. ,70 ,30) ,0. ,2* pi , pi /100)
>>> drawCurve ( parametric_hyperbola ( -50. ,0. ,70 ,30) , -1. ,1. ,0.1)
>>> drawCurve ( parametric_cycloid ( -150. , -100. ,20.) ,0. ,5* pi , pi /100)
>>> drawCurve ( par amet ric_e picy cloid ( -100. ,75. ,40. ,4.) ,0. ,2* pi , pi /100)
>>> drawCurve ( p ar am e tr i c_ hy p er c yc lo i d (100. ,75. ,40. ,6.) ,0. ,8* pi , pi /100)
>>> drawCurve ( pascal_snail ( -150. ,0. ,100. ,80.) ,0. ,2* pi , pi /100)
>>> drawCurve ( logarithmic_spiral (100. ,0. ,0.1) ,0. ,7. , pi /50)
"""
assert type ( t1 ) is float
assert type ( t2 ) is float
assert type ( dt ) is float
19
20
21
22
23
24
25
26
27
28
29
30
values = []
t = t1 + dt
while t < t2 :
append ( values , t )
t = t + dt
up ()
goto ( fx ( t1 ) , fy ( t1 ))
down ()
for t in values :
goto ( fx ( t ) , fy ( t ))
return
La fonction drawCurve ncessite de passer en argument 2 noms de fonction fx et fy

e
faisant rfrence respectivement ` lquation paramtrique x(t) et y(t). Par exemple, pour
ee
a e
e
un cercle de rayon r = 1, on pourra appeler la fonction drawCurve de la mani`re suivante :
e
drawCurve((cos,sin),0.,2*pi,pi/100). Si lon veut tracer, un cercle de rayon r = 40
e
centr en (x0 = 10, y0 = 5), on pourra dnir les fonctions cx et cy telles que :
e

148
def cx(t):
x0 = -10
r = 40
return x0 + r*cos(t)
def cy(t):
y0 = 5
r = 40
return y0 + r*sin(t)
et appeler drawCurve de la mani`re suivante : drawCurve((cx,cy),0.,2*pi,pi/100).

e
Malheureusement, ce dernier procd nest pas susamment gnrique. En eet, si on
e e
e e
veut maintenant tracer un cercle de rayon r = 20 centr en (0, 34), il faudra rednir
e
e
les fonctions cx et cy ou dnir 2 nouvelles fonctions pour ce nouveau trac. Ainsi, d`s
e
e
e
que lon voudra dessiner un cercle de rayon r centr en (x0 , y0 ), il faudra recommencer
e
cette opration : ce qui nest nalement pas tr`s oprationnel. Pour tre plus ecace,
e
e
e
e
on utilisera la directive lambda du langage Python qui permet de dnir une fonction
e
anonyme (sans nom) qui peut tre retourne par une autre fonction. Ainsi, pour le cercle,
e
e
on dnira la fonction parametric circle de faon ` ce quelle retourne un doublet de
e
c a
fonctions anonymes paramtrables :
e
def parametric_circle(x0,y0,r):
return lambda(t): x0 + r * cos(t), lambda(t): y0 + r * sin(t)
Nous pourrons alors appeler la fonction drawCurve avec comme premier argument un
appel ` la fonction parametric circle qui sera remplace par le doublet de fonctions
a
e
anonymes :
- pour un cercle de rayon r = 40 centr en (10, 5) :
e
drawCurve(parametric circle(10,5,40),0.,2*pi,pi/100)
- pour un cercle de rayon r = 20 centr en (0, 34) :
e
drawCurve(parametric circle(0,20,-34),0.,2*pi,pi/100)
- et de mani`re gnrale pour un cercle de rayon r centr en (x0 , y0 ) :
e
e e
e
drawCurve(parametric circle(x0,y0,r),0.,2*pi,pi/100)
Nous donnons ci-dessous 9 exemples de fonctions pour dnir des familles de courbes
e
paramtres : droites, cercles, ellipses, hyperboles, cyclo
e e
des, picyclo
e
des, hypocyclo
des,
limaons de Pascal et spirales algorithmiques.
c

Droite paramtrique
e
1
2
3
4
5
6
7
def parametric_line ( x0 , y0 , alpha , beta ):

"""
droite param trique
e
x = x0 + alpha *t , y = y0 + beta * t
"""
return lambda ( t ): x0 + alpha *t ,
lambda ( t ): y0 + beta * t
Cercle paramtrique
e
1
2
3
4
5
6
7
def parametric_circle ( x0 , y0 , r ):
"""
cercle param trique
e
x = x0 + r * cos ( theta ) , y = y0 + r * sin ( theta )
"""
return lambda ( theta ): x0 + r * cos ( theta ) ,
lambda ( theta ): y0 + r * sin ( theta )
Ellipse paramtrique
e
1
2
3
4
5
6
7
def parametric_ellipse ( x0 , y0 ,a , b ):
"""
ellipse param trique
e
x = x0 + a * cos ( phi ) , y = y0 + b * sin ( phi )
"""
return lambda ( phi ): x0 + a * cos ( phi ) ,
lambda ( phi ): y0 + b * sin ( phi )
Hyperbole paramtrique
e
1
2
3
4
5
6
7
def parametric_hyperbola ( x0 , y0 ,a , b ):
"""
hyperbole param trique
e
x = x0 + a / cos ( theta ) , y = y0 + b * tan ( theta )
"""
return lambda ( theta ): x0 + a / cos ( theta ) ,
lambda ( theta ): y0 + b * tan ( theta )
149

150
Cyclo paramtrique
de
e
1
2
3
4
5
6
7
def parametric_cycloid ( x0 , y0 , r ):
"""
cyclo de param trique
e
x = x0 + r *( phi - sin ( phi )) , y = y0 + r *(1 - cos ( phi ))
"""
return lambda ( phi ): x0 + r *( phi - sin ( phi )) ,
lambda ( phi ): y0 + r *(1 - cos ( phi ))
Epicyclo paramtrique
de
e
1
2
3
4
5
6
7
8
def par amet ric_e picy cloid ( x0 , y0 ,R , r ):

"""
e
picyclo de param trique
e
x = x0 + ( R + r )* cos ( theta ) - r * cos ( theta *( R + r )/ r ) ,
x = y0 + ( R + r )* sin ( theta ) - r * sin ( theta *( R + r )/ r )
"""
return lambda ( theta ): x0 + ( R + r )* cos ( theta ) - r * cos ( theta *( R + r )/ r ) ,
lambda ( theta ): y0 + ( R + r )* sin ( theta ) - r * sin ( theta *( R + r )/ r )
Hypercyclo paramtrique
de
e
1
2
3
4
5
6
7
8
def p ar am e tr i c_ hy p er c yc lo i d ( x0 , y0 ,R , r ):
"""
hypercyclo de param trique
e
x = x0 + (R - r )* cos ( theta ) + r * cos ( theta *( R - r )/ r ) ,
x = y0 + (R - r )* sin ( theta ) + r * sin ( theta *( R - r )/ r )
"""
return lambda ( theta ): x0 + (R - r )* cos ( theta ) + r * cos ( theta *( R - r )/ r ) ,
lambda ( theta ): y0 + (R - r )* sin ( theta ) + r * sin ( theta *( R - r )/ r )

151
Limaon de Pascal
c
1
2
3
4
5
6
7
8
def pascal_snail ( x0 , y0 ,a , b ):
"""
lima on de Pascal
c
x = x0 + ( a * cos ( theta ) +
y = y0 + ( a * cos ( theta ) +
"""
return lambda ( theta ): x0
lambda ( theta ): y0
b )* cos ( theta )
b )* sin ( theta )
+ ( a * cos ( theta ) + b )* cos ( theta ) ,
+ ( a * cos ( theta ) + b )* sin ( theta )
Spirale logarithmique
1
2
3
4
5
6
7
8
def logarithmic_spiral ( x0 , y0 , k ):
"""
spirale logarithmique
x = x0 + k * exp ( theta )* cos ( theta )
y = y0 + k * exp ( theta )* sin ( theta )
"""
return lambda ( theta ): x0 + k * exp ( theta )* cos ( theta ) ,
lambda ( theta ): y0 + k * exp ( theta )* sin ( theta )
Remarque : Ce procd qui consiste ` passer une fonction lambda en argument dune
e e
a
fonction aurait pu tre utilis dans le cas des fonctions dintgration numrique du
e
e
e
e
TD 3.23 prcdent.
e e
Exemples : >>> f = lambda(x): 3*x + 5
>>> simpson_integration(f,-1.,1.,100)
10.0
>>> g = lambda(x): sin(cos(x))
>>> simpson_integration(g,-pi/2.,pi/2.,10000)
1.7864874819500629

152
3.5
Annexes
3.5.1
Instructions Logo
Logo is the name for a philosophy of education and a continually evolving family of programming languages
that aid in its realization (Harold Abelson, Apple Logo, 1982). This statement sums up two fundamental
aspects of Logo and puts them in the proper order. The Logo programming environments that have been
developed over the past 28 years are rooted in constructivist educational philosophy, and are designed to
support constructive learning. [. . .] Constructivism views knowledge as being created by learners in their
own minds through interaction with other people and the world around them. This theory is most closely
associated with Jean Piaget, the Swiss psychologist, who spent decades studying and documenting the learning
processes of young children.
Logo Foundation : http://el.media.mit.edu/logo-foundation
On suppose connues les procdures de tracs gomtriques ` la Logo :

e
e e e
a
degrees() xe lunit dangle en degrs
e
e
radians() xe lunit dangle en radians
e
reset() eace lcran et rinitialise les variables
e
e
clear() eace lcran
e
up() l`ve le crayon
e
down() abaisse le crayon
forward(d) avance dune distance d
backward(d) recule dune distance d
left(a) tourne sur la gauche dun angle a
right(a) tourne sur la droite dun angle a
goto(x,y) dplace le crayon ` la position (x, y)
e
a
towards(x,y) oriente vers le point de coordonnes (x, y)
e
setheading(a) oriente dun angle a par rapport ` laxe des x
a
position() donne la position (x, y) du crayon
heading() donne lorientation a du dplacement
e
circle(r) trace un cercle de rayon r
circle(r,a) trace un arc de cercle de rayon r et dangle au sommet a.
3.5. ANNEXES
3.5.2
153
Fonctions Python prdnies

e e
Les principales fonctions prdnies en Python sont listes dans les tableaux ci-dessous,
e e
e
extraits du Python 2.5 Quick Reference Guide [10].
Function
abs(x)
all(iterable)
any(iterable)
bool([x])
chr(i)
cmp(x,y)
complex(real[, image])
dict([mapping-or-sequence])
dir([object])
divmod(a,b)
enumerate(iterable)
eval(s[, globals[, locals]])
execfile(file[, globals[,locals]])
filter(function,sequence)
float(x)
globals()
help([object])
hex(x)
id(object)
Result
Returns the absolute value of the number x.
Returns True if bool(x) is True for all values x in the iterable.
Returns True if bool(x) is True for any values x in the iterable.
Converts a value to a Boolean, using the standard truth testing procedure. If x is false or omitted, returns False ; otherwise
returns True.
Returns one-character string whose ASCII code is integer i.
Returns negative, 0, positive if x <, ==, > to y respectively.
Creates a complex object (can also be done using J or j sux,
e.g. 1+3J).
Returns a new dictionary initialized from the optional argument
(or an empty dictionary if no argument). Argument may be a
sequence (or anything iterable) of pairs (key,value).
Without args, returns the list of names in the current local symbol table. With a module, class or class instance object as arg,
returns the list of names in its attr. dictionary.
Returns tuple (a//b, a%b).
Iterator returning pairs (index, value) of iterable, e.g.
List(enumerate(Py)) [(0, P), (1, y)].
Evaluates string s, representing a single python expression, in
(optional) globals, locals contexts.
Example : x = 1 ; assert eval(x + 1) == 2
Executes a file without creating a new module, unlike import.
Constructs a list from those elements of sequence for which
function returns true. function takes one parameter.
Converts a number or a string to oating point.
Returns a dictionary containing the current global variables.
Invokes the built-in help system. No argument interactive
help ; if object is a string (name of a module, function, class,
method, keyword, or documentation topic), a help page is printed on the console ; otherwise a help page on object is generated.
Converts a number x to a hexadecimal string.
Returns a unique integer identier for object.
154
Function
input([prompt])
int(x[, base])
len(obj)
list([seq])
locals()
map(function, sequence)
oct(x)
open(filename[,mode=r,[bufsize]])
ord(c)
range([start,] end [, step])
raw input([prompt])
reload(module)
repr(object)
round(x, n=0)
str(object)
sum(iterable[, start=0])
tuple([seq])
type(obj)
xrange(start [, end [, step]])
Result
Prints prompt if given. Reads input and evaluates it.
Converts a number or a string to a plain integer. Optional base
parameter species base from which to convert string values.
Returns the length (the number of items) of an object (sequence,
dictionary).
Creates an empty list or a list with same elements as seq. seq
may be a sequence, a container that supports iteration, or an
iterator object. If seq is already a list, returns a copy of it.
Returns a dictionary containing current local variables.
Returns a list of the results of applying function to each item
from sequence(s).
Converts a number to an octal string.
Returns a new le object. filename is the le name to be opened.
mode indicates how the le is to be opened (r, w, a,
+, b, U). bufsize is 0 for unbuered, 1 for line buered,
negative or omitted for system default, >1 for a buer of (about)
the given size.
Returns integer ASCII value of c (a string of len 1).
Returns list of ints from >= start and < end. With 1 arg, list
from 0..arg-1. With 2 args, list from start..end-1. With 3
args, list from start up to end by step.
Prints prompt if given, then reads string from std input (no
trailing n).
Re-parses and re-initializes an already imported module.
Returns a string containing a printable and if possible evaluable
representation of an object. object (using backquotes).
Returns the oating point value x rounded to n digits after the
decimal point.
Returns a string containing a nicely printable representation of
an object.
Returns the sum of a sequence of numbers (not strings), plus the
value of parameter. Returns start when the sequence is empty.
Creates an empty tuple or a tuple with same elements as seq.
Returns a type object representing the type of obj.
Like range(), but doesnt actually store entire list all at once.
Good to use in for loops when there is a big range and little
memory.
3.5. ANNEXES
3.5.3
155
Fonctions en Python
Le principe de la dnition dune fonction en Python est prsente ci-dessous (dapr`s le

e
e
e
e
Python 2.5 Quick Reference Guide [10]).
def funcName([paramList]) :
block
Creates a function object and binds it to name funcName.

paramList : := [param [, param]*]
param : := value | id=value | *id | **id
Arguments are passed by value, so only arguments representing a mutable object can be
modied (are inout parameters).
Use return to return None from the function, or return value to return a value. Use a
tuple to return more than one value, e.g. return 1,2,3.
Keyword arguments arg=value specify a default value (evaluated at function denition
time). They can only appear last in the param list, e.g. foo(x, y=1, s=).
Pseudo-arg *args captures a tuple of all remaining non-keyword args passed to the function, e.g. if def foo(x, *args) : ... is called foo(1, 2, 3), then args will contain
(2,3).
Pseudo-arg **kwargs captures a dictionary of all extra keyword arguments, e.g. if def
foo(x, **kwargs) : ... is called foo(1, y=2, z=3), then kwargs will contain {y :2,
z :3}. if def foo(x, *args, **kwargs) : ... is called foo(1, 2, 3, y=4, z=5),
then args will contain (2, 3), and kwargs will contain {y :4, z :5}.
args and kwargs are conventional names, but other names may be used as well.
*args and **kwargs can be forwarded (individually or together) to another function,
e.g. def f1(x, *args, **kwargs) : f2(*args, **kwargs).

156
3.5.4
Lutilitaire pydoc
Cette annexe est un extrait du site ociel Python concernant pydoc : http://docs.python.org
/lib/module-pydoc.html. La gure 3.20 ci-contre illustre son utilisation.
Fig. 3.20 : Documentation en Python
pydoc est test ici avec lexemple qui nous a servi de
e
l rouge tout au long de la section 3.2.
$ pydoc fibo
Help on module fibo :
NAME
fibo
FILE
/home/info/S1/cours/fonctions/fibo.py
FUNCTIONS
fibonacci(n)
u = fibonacci(n)
a
` lordre n si n :int >= 0
>>> fibonacci(0)
1
>>> fibonacci(2)
2
>>> fibonacci(9)
55
pydoc Documentation generator and online help system

The pydoc module automatically generates documentation from Python modules. The documentation can be presented as pages of text on the console, served to a Web browser, or saved
to HTML les.
The built-in function help() invokes the online help system in the interactive interpreter,
which uses pydoc to generate its documentation as text on the console. The same text documentation can also be viewed from outside the Python interpreter by running pydoc as a script at
the operating systems command prompt. For example, running
pydoc sys
at a shell prompt will display documentation on the sys module, in a style similar to the manual
pages shown by the Unix man command. The argument to pydoc can be the name of a function,
module, or package, or a dotted reference to a class, method, or function within a module or
module in a package. If the argument to pydoc looks like a path (that is, it contains the path
separator for your operating system, such as a slash in Unix), and refers to an existing Python
source le, then documentation is produced for that le.
Specifying a -w ag before the argument will cause HTML documentation to be written out
to a le in the current directory, instead of displaying text on the console.
Specifying a -k ag before the argument will search the synopsis lines of all available modules
for the keyword given as the argument, again in a manner similar to the Unix man command.
The synopsis line of a module is the rst line of its documentation string.
You can also use pydoc to start an HTTP server on the local machine that will serve documentation to visiting Web browsers. pydoc -p 1234 will start a HTTP server on port 1234,
allowing you to browse the documentation at http ://localhost :1234/ in your preferred
Web browser. pydoc -g will start the server and additionally bring up a small Tkinter-based
graphical interface to help you search for documentation pages.
When pydoc generates documentation, it uses the current environment and path to locate
modules. Thus, invoking pydoc spam documents precisely the version of the module you would
get if you started the Python interpreter and typed import spam.
Chapitre 4
Structures linaires
e
Sommaire
4.1
4.2
Informatique
S1
4.3
a
structures linaires
e
4.4
Jacques TISSEAU
4.5

o
enib c 2009
4.6
tisseau@enib.fr
enib c 2009
Algorithmique
1/13
,
157
Introduction . . . . . . . . . . . . . . . .
4.1.1 Types de donnes . . . . . . . . .
e
4.1.2 Collections . . . . . . . . . . . . .
Squences . . . . . . . . . . . . . . . . . .
e
4.2.1 N-uplets . . . . . . . . . . . . . .
4.2.2 Cha
nes de caract`res . . . . . .
e
4.2.3 Listes . . . . . . . . . . . . . . . .
4.2.4 Piles et les . . . . . . . . . . . .
4.2.5 Listes multidimensionnelles . . .
Recherche dans une squence . . . . . .
e
4.3.1 Recherche squentielle . . . . . .
e
4.3.2 Recherche dichotomique . . . . .
Tri dune squence . . . . . . . . . . . . .
e
4.4.1 Tri par slection . . . . . . . . . .
e
4.4.2 Tri par insertion . . . . . . . . .
4.4.3 Tri rapide . . . . . . . . . . . . . .
Exercices complmentaires . . . . . . . .
e
4.5.1 Conna
tre . . . . . . . . . . . . . .
4.5.2 Comprendre . . . . . . . . . . . .
4.5.3 Appliquer . . . . . . . . . . . . . .
4.5.4 Analyser . . . . . . . . . . . . . .
4.5.5 Evaluer . . . . . . . . . . . . . . .
4.5.6 Solutions des exercices . . . . . .
Annexes . . . . . . . . . . . . . . . . . . .
4.6.1 Type abstrait de donnes . . . .
e
4.6.2 Codes ASCII . . . . . . . . . . . .
4.6.3 Les squences en Python . . . .
e
4.6.4 Les chiers en Python . . . . . .
4.6.5 Mthode dlimination de Gauss
e
e
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
158
158
160
162
163
164
165
167
168
170
171
172
173
174
175
177
180
180
182
183
184
184
185
193
193
194
194
198
199

CHAPITRE 4. STRUCTURES LINEAIRES
158
4.1
DONNEE n. f. XIIIe si`cle, au sens de distrie

bution, aumne ; XVIIIe si`cle, comme terme de
o
e
mathmatiques. Participe pass fminin substantiv
e
e e
e
de donner au sens de indiquer, dire . 1. Fait ou
principe indiscut, ou considr comme tel, sur lee
e e
quel se fonde un raisonnement ; constatation servant
de base ` un examen, une recherche, une dcouverte.
a
e
MATH. Chacune des quantits ou proprits mene
ee
tionnes dans lnonc dun probl`me et qui pere
e
e
e
mettent de le rsoudre. INFORM. Reprsentation
e
e
dune information sous une forme conventionnelle
adapte ` son exploitation.
e a
COLLECTION n. f. XIVe si`cle, au sens de amas
e
de pus ; XVIIe si`cle, au sens moderne. Emprunt
e
e
du latin collectio, action de recueillir, de rassembler , ce qui est recueilli . 1. Ensemble dobjets
de mme sorte que lon runit volontairement dans
e
e
un esprit de curiosit, ou pour leur valeur artistique,
e
scientique ou documentaire.
TD 4.1 : Distance de 2 points de lespace

Dnir la fonction distance qui calcule la distance entre
e
2 points M1 et M2 de lespace, respectivement de coordonnes (x1 , y1 , z1 ) et (x2 , y2 , z2 ).
e
Introduction
e
e
a
rsoudre une srie de probl`mes quivalents. Les deux chapitres prcdents concernaient la struce
e
e
e
e e
turation des algorithmes, soit en contrlant le ux dinstructions ` laide dinstructions de base
o
a
appropries (chapitre 2), soit en factorisant des squences dinstructions au sein de fonctions et
e
e
procdures (chapitre 3). Par contre, ils ne sintressaient pas explicitement aux donnes manie
e
e
pules par ces algorithmes. Ce sera lobjet de ce chapitre daborder la structuration des donnes
e
e
manipules par les algorithmes.
e
Exemple 4.1 : Distance entre 2 points du plan
Soient deux points du plan M1 et M2 respectivement de coordonnes (x1 , y1 ) et (x2 , y2 ). La
e
distance d entre ces 2 points est classiquement calcule par d = (x2 x1 )2 + (y2 y1 )2 dont
e
on dduit limplmentation informatique suivante :
e
e
def distance(x1,y1,x2,y2) :
return sqrt((x2-x1)**2 + (y2-y1)**2)
>>> distance(0,0,1,1)
1.4142135623730951
La fonction distance prcdente prend 4 arguments (les 4 coordonnes x1 , y1 , x2 , y2 ) l` o`

e e
e
a u
lutilisateur de la fonction aurait certainement prfr parler plus directement des 2 points M1
eee
et M2 . Pour cela, il faut tre capable de runir 2 par 2 les coordonnes des 2 points au sein
e
e
e
o
e
dune mme collection de donnes (gure 4.1) et passer des points plutt que des coordonnes.
e
e
Cest ce qui est propos dans limplmentation suivante en utilisant les n-uplets de Python o`
e
e
u
la fonction ne prend plus que 2 arguments (les 2 points M1 et M2 ).
def distance(m1,m2) :
return sqrt((m2[0]-m1[0])**2 + (m2[1]-m1[1])**2)
>>> m1, m2 = (0,0), (1,1)

>>> distance(m1,m2)
1.4142135623730951
TD4.1
Ce regroupement de coordonnes permet de dnir la notion de point l` o` ne manipulait

e
e
a u
initialement que des coordonnes. On introduit ainsi de nouveaux types de donnes.
e
e
4.1.1
Types de donnes
e
En informatique, une donne est la reprsentation dune information sous une forme convene
e
tionnelle adapte ` son exploitation. Une variable est alors un objet informatique qui associe
e a
un nom ` cette reprsentation (section 2.2.1 page 42) et qui, selon les langages, est implicitea
e
ment ou explicitement type. On distingue classiquement les types de base comme les boolens
e
e
4.1. INTRODUCTION
159
(type bool, {False,True}), les entiers (type int, en fait un sous-ensemble des nombres
relatifs Z) et les rels (type float, en fait un sous-ensemble des nombres rationnels Q) des
e
types structurs qui sont des regroupements de types tels que les listes (type list, exemple :
e
[0,3.14,[4,True]]), les n-uplets (type tuple, exemple : (0,3.14,[4,(True,8)]) ou les dictionnaires (type dict, exemple : {a : [1,2,3], b : 5}).
Dnition 4.1 : type de donnees

e
Le type dune variable dnit lensemble des valeurs quelle peut prendre et lensemble des
e
oprations quelle peut subir.
e
Dune mani`re plus formelle, on dnit des types abstraits de donnes (Tad) o` les donnes
e
e
e
u
e
sont considres de mani`re abstraite indpendamment dune implmentation dans un langage
ee
e
e
e
donn sur une machine particuli`re. On choisit alors une notation pour les dcrire ainsi que pour
e
e
e
dcrire lensemble des oprations quon peut leur appliquer et les proprits de ces oprations.
e
e
ee
e
Il existe plusieurs mani`res de dnir un type abstrait de donnes qui di`rent essentiellement
e
e
e
e
dans la faon de dcrire les proprits des oprations du type. Lannexe 4.6.1 page 193 propose
c
e
ee
e
un exemple de type abstrait de squence fond sur un formalisme logique [13], mais dans ce qui
e
e
suit (section 4.2) nous aborderons les squences de mani`re plus pragmatique et oprationnelle.
e
e
e
On peut ainsi regrouper nimporte quelles donnes entre elles pour former un nouveau type
e
de donnes comme :
e
un nombre rationnel form de 2 entiers : le numrateur et le dnominateur (exemple :
e
e
e
(n,d) pourra reprsenter le rationnel n/d),
e
un nombre complexe form de 2 rels : la partie relle et la partie imaginaire (exemple :
e
e
e
(x,y) pourra reprsenter le complexe x + iy),
e
un vecteur de lespace form de 3 rels : labscisse, lordonne et la cte (exemple : (x,y,z)
e
e
e
o
pourra reprsenter le vecteur de R3 de composantes (x, y, z)),
e
une che dtat civil form de 3 cha
e
e
nes de caract`res et dun entier : le nom, le prnom,
e
e
la nationalit et lge (exemple : (nom,prenom,pays,age)) pourra reprsenter lindividu
e
a
e
nom prenom originaire de pays et g de age ans.
a e
Dans les exemples prcdents, le nombre dlments qui composent le regroupement est connu
e e
ee
a
` lavance (un rationnel sera toujours compos de 2 entiers, un vecteur de R3 aura toujours
e
3 composantes relles. . .). Mais ce nest pas toujours le cas ; on parlera alors de collections de
e
donnes.
e
Remarque 4.1 : En Python, les principaux types de

base sont les boolens (bool), les entiers (int), les rels
e
e
(float), les complexes (complex), les cha
nes de caract`res (str), les n-uplets (tuple), les listes (list), les
e
ensembles (set), les chiers (file) et les dictionnaires
(dict).
Remarque 4.2 : On pourra galement consulter [9]

e
pour approfondir cette notion de type abstrait de donnes,
e
en particulier dans le cas des squences et des principaux
e
algorithmes associs de recherche et de tri.
e

160
4.1.2
Collections
Dnition 4.2 : collection de donnees

e
Une collection est un regroupement ni de donnes dont le nombre nest pas x a priori.
e
e
Ainsi les collections que lon utilise en informatique sont des objets dynamiques. Le nombre
de leurs lments varie au cours de lexcution du programme, puisquon peut y ajouter et
ee
e
supprimer des lments en cours de traitement. Plus prcisment les principales oprations que
ee
e e
e
lon sautorise sur les collections sont les suivantes :
dterminer le nombre dlments de la collection,
e
ee
tester lappartenance dun lment ` la collection,
ee
a
ajouter un lment ` la collection,
ee
a
supprimer un lment de la collection.
ee
Fig. 4.2 : Exemple de collection

Tas de chaussures
Exemple 4.2 : Tas de chaussures

Dans le tas de chaussures de la gure 4.2 ci-contre, il est tr`s facile dajouter une paire de
e
chaussures sur le tas : il sut de la jeter sans prcaution sur les autres chaussures. Par contre,
e
pour supprimer une chaussure particuli`re du tas, ce sera beaucoup plus dicile car il faudra
e
dabord la retrouver dans cet amas non structur de chaussures.
e
Fig. 4.3 : Elements dune sequence
prdcesseur
Exemple de squence : main au poker

e
successeur
A linverse du tas de chaussures, les collections informatiques seront structures pour faciliter
e
et optimiser la recherche dun lment en leur sein. Les lments peuvent tre de dirents types,
ee
ee
e
e
mais les oprations que lon eectue sur les collections doivent tre indpendantes des types de
e
e
e
donnes des lments.
e
ee
On distingue classiquement 3 grands types de collections : les squences, les arbres et les
e
graphes.
Dnition 4.3 : sequence

e
Une squence est une suite ordonne dlments, ventuellement vide, accessibles par leur rang
e
e
ee
e
dans la squence.
e
Dans une squence (gure 4.3), chaque lment a un prdecesseur (sauf le premier lment
e
ee
e
ee
qui na pas de prdcesseur) et un successeur (sauf le dernier lment qui na pas de successeur).
e e
ee
Une liste de noms, une main dun jeu de cartes, une pile dassiettes ou une le de spectateurs
sont des exemples de structures squentielles de la vie courante. En Python, on utilisera 3
e
types de squences : les cha
e
nes de caract`res (type str, exemples : , bonjour, "a va ?"),
e
c
4.1. INTRODUCTION
161
les n-uplets (type tuple, exemples : (), (1,2,3), (a,2,(1,2,3))) et les listes (type list,
exemples : [], [a,b,c,d,e], [1,e,(1,2,[x,y])]).
Dnition 4.4 : arbre
e
Un arbre est une collection dlments, appels nuds , organiss de faon hirarchique `
ee
e
e
c
e
a
partir dun nud particulier, appel la racine de larbre.
e
Fig. 4.4 : Nud dun arbre
prdcesseur
Dans un arbre (gure 4.4), chaque lment a un seul prdecesseur (sauf la racine de larbre
ee
e
qui na pas de prdecesseur) et peut avoir plusieurs successeurs (on appelle feuille de larbre
e
un nud qui na pas de successeurs). Larbre est dit n-aire si chaque nud a au plus n
successeurs ; si n = 2, on parle darbre binaire. Les rpertoires dun syst`me dexploitation en
e
e
informatique, la classication des esp`ces animales en biologie ou le tableau nal dun tournoi
e
de tennis constituent des exemples connus de structures arborescentes.
Exemple 4.3 : Tableau final dun tournoi de football
Dans lexemple de la gure 4.5 ci-contre, les nuds de larbre sont les rencontres (exemples :
le quart de nale Portugal/Turquie, la demi-nale Pays-Bas/Italie). Il sagit dun arbre binaire
dont la racine est la nale France/Italie. Les quarts de nale sont les feuilles de cet arbre binaire.
successeurs
Fig. 4.5 : Exemple darbre

Tableau nal de lEuro 2000 de football
En Python, les ensembles (type set) et les dictionnaires (type dict) sont implments sous
e
e
forme darbres.
Dnition 4.5 : graphe
e
Un graphe est une collection dlments, appels sommets , et de relations entre ces sommets.
ee
e
Dans un graphe (gure 4.6), chaque lment peut avoir plusieurs prdcesseurs et plusieurs
ee
e e
successeurs. Un mme lment peut tre ` la fois prdcesseur et successeur dun autre sommet
e
ee
e
a
e e
(y compris de lui-mme). On parle de graphe orient lorsque les relations entre sommets sont
e
e
des paires ordonnes de sommets (les relations sont alors appeles arcs du graphe) ; on parle
e
e
de graphe non orient si ce sont des paires non orientes (les relations sont alors appeles
e
e
e
artes du graphe). Un graphe est facilement reprsentable par un schma (gure 4.7) o` les
e
e
e
u
sommets sont des points et les arcs, des `ches entre deux points (ou les artes, des traits entre
e
e
deux points). Un circuit lectronique, une toile daraigne ou internet sont des exemples de tels
e
e
graphes.
Les graphes permettent de manipuler plus facilement des objets et leurs relations. Lensemble
des techniques et outils mathmatiques mis au point en Thorie des Graphes permettent
e
e
Fig. 4.6 : Sommet dun graphe
prdcesseurs
a
successeurs

162
de dmontrer certaines proprits des graphes, den dduire des mthodes de rsolution, des
e
ee
e
e
e
algorithmes. . .
Fig. 4.7 : Schema dun graphe oriente
`
Exemple 4.4 : Carte routiere
Dans la carte routi`re de la gure 4.8, les villes sont les sommets dun graphe non orient dont
e
e
les artes sont les routes qui m`nent dune ville ` lautre. Sur un tel graphe, on peut se poser
e
e
a
des questions telles que :
Quel est le plus court chemin (en distance ou en temps) pour se rendre dune ville ` une
a
autre ?
Comment optimiser le circuit dun voyageur de commerce de telle mani`re quil passe une
e
et une seule fois par toutes les villes de son secteur ?
Dans ce chapitre, nous ne nous intresserons quaux structures linaires : les squences. Les
e
e
e
structures arborescentes et les graphes seront abords ` partir du semestre 4 dans les cours
e a
dinformatique de lENIB.
Fig. 4.8 : Exemple de graphe

Carte routi`re du Finist`re Nord
e
e
4.2
Squences
e
Comme en Python, nous distinguerons ici les n-uplets (type tuple), les cha
nes de caract`res
e
(type str) et les listes (type list) comme autant de variantes de squences. Quelle que soit
e
la variante considre, il sera toujours possible de dterminer le type (type(s)) et la longueur
ee
e
(len(s)) dune squence s, de tester lappartenance dun lment x ` la squence s (x in s),
e
ee
a
e
daccder ` un lment par son rang i dans la squence (s[i]) et de concatner 2 squences s1
e
a
ee
e
e
e
et s2 (s1 + s2).
>>> s = 1,7,2,4
>>> type(s)
<type tuple>
>>> len(s)
4
>>> 3 in s
False
>>> s[1]
7
>>> s + (5,3)
(1, 7, 2, 4, 5, 3)
>>> s = 1724
>>> type(s)
<type str>
>>> len(s)
4
>>> 3 in s
False
>>> s[1]
7
>>> s + 53
172453
>>> s = [1,7,2,4]
>>> type(s)
<type list>
>>> len(s)
4
>>> 3 in s
False
>>> s[1]
7
>>> s + [5,3]
[1, 7, 2, 4, 5, 3]
Les variantes tuple, str et list di`rent par leur syntaxe et par le fait quune liste est
e

4.2. SEQUENCES
163
modiable alors que les n-uplets et les cha

nes de caract`res ne le sont pas, au sens o` il nest
e
u
pas possible de modier un lment individuel dune cha ou dun n-uplet.
ee
ne
>>> s = 1,7,2,4
>>> type(s)
<type tuple>
>>> s[1] = 3
Traceback ...
TypeError : tuple
object does not support
item assignment
>>> s[1]
7
4.2.1
>>> s = 1724
>>> type(s)
<type str>
>>> s[1] = 3
Traceback ...
TypeError : str object
does not support item
assignment
>>> s[1]
7
>>> s = [1,7,2,4]
>>> type(s)
<type list>
>>> s[1] = 3
>>> s
[1, 3, 2, 4]
>>> s[1]
3
Remarque 4.3 : Attention ! Par convention, les indices des lments dans une squence commencent ` 0.
ee
e
a
Le premier lment a pour indice 0 (s[0]), le deuxi`me
ee
e
lindice 1 (s[1]), le troisi`me lindice 2 (s[2]) et ainsi de
e
suite jusquau dernier qui a lindice n-1 (s[n-1]) si n est
le nombre dlments dans la squence (n == len(s)).
ee
e
Remarque 4.4 : La section 4.6.3 page 194 prsente les
e
principales oprations sur les squences en Python.
e
e
N-uplets
Dnition 4.6 : n-uplet

e
Un n-uplets est une squence non modiable dlments.
e
ee
On parle de singleton quand n = 1, de paire quand n = 2, de triplet pour n = 3, de quadruplet
pour n = 4. . . et plus gnralement de n-uplet.
e e
Dun point de vue syntaxique, un n-uplet est une suite dlments spars par des virgules.
ee
e e
Bien que cela ne soit pas ncessaire, il est conseill de mettre un n-uplet en vidence en lene
e
e
fermant dans une paire de parenth`ses, comme Python le fait lui-mme. Par ailleurs, il faut
e
e
toujours au moins une virgule pour dnir un n-uplet, sauf pour le n-uplet vide ().
e
>>> s = ()
>>> type(s)
<type tuple>
>>> s = 1,7,2,4
>>> type(s)
<type tuple>
>>> s
(1, 7, 2, 4)
>>> s = (5)
>>> type(s)
<type int>
>>> s = (5,)
>>> type(s)
<type tuple>
>>> s = (5,)+()+(6,7,9)
>>> s
(5, 6, 7, 9)
>>>
>>>
(6,
>>>
(6,
>>>
(5,
>>>
(7,
s = (5,6,7,9)
s[1:3]
7)
s[1:]
7, 9)
s[:2]
6)
s[-2:]
9)
TD 4.2 : Operations sur les n-uplets

Donner un exemple dutilisation de chacune des oprae
tions sur les n-uplets dcrites dans le tableau de la page
e
195.
TD4.2
Les n-uplets sont souvent utiliss pour regrouper sous une mme variable plusieurs vae
e
riables logiquement relies entre elles comme dans lexemple des points du plan de lexemple
e
4.1 page 158. Ils servent galement ` retourner plusieurs objets dans une fonction comme dans
e
a
TD 4.3 : Pgcd et ppcm de 2 entiers (2)

voir TD 3.10 Dnir une fonction qui calcule le pgcd et
e
le ppcm de 2 entiers a et b.

164
les exemples de la fonction standard divmod de la section 3.5.2 page 153 ou encore des dnitions
e
de courbes paramtriques du TD 3.24 page 136.
e
TD4.3
4.2.2
Cha
nes de caract`res
e
`
Dnition 4.7 : cha de caracteres
e
ne
Une cha de caract`res est une squence non modiable de caract`res.
ne
e
e
e
Remarque 4.5 : Lordinateur stocke toutes les
donnes sous forme numrique (ensemble de bits). En
e
e
particulier, les caract`res ont un quivalent numrique :
e
e
e
le code ASCII (American Standard Code for Information
Interchange). Le code ASCII de base code les caract`res
e
sur 7 bits (128 caract`res : de 0 ` 127, voir section 4.6.2
e
a
page 194).
En Python, les fonctions standard ord et chr permettent
de passer du caract`re au code ASCII et inversement.
e
>>> chr(101)
>>> ord(e)
e
101
>>> chr(233)
>>> ord()
e
e
233
TD 4.4 : Operations sur les cha

nes
tions sur les cha
nes de caract`res dcrites dans le tableau
e
e
de la page 196.
Dun point de vue syntaxique, une cha de caract`res est une suite quelconque de caract`res
ne
e
e
dlimite soit par des apostrophes (simple quotes : ...), soit par des guillemets (double quotes :
e
e
"..."). On peut ainsi utiliser des guillemets pour dlimiter une cha dans laquelle il y a des
e
ne
apostrophes (exemple : "cest a !"), ou utiliser des apostrophes pour dlimiter une cha qui
c
e
ne
contient des guillemets (exemple : "hello" dit-il.). Pour sa part, le caract`re antislash (\)
e
permet dcrire sur plusieurs lignes une cha qui serait trop longue pour tenir sur une seule
e
ne
ou bien dinsrer, ` lintrieur dune cha
e
a
e
ne, un certain nombre de caract`res spciaux comme
e
e
les sauts ` la ligne (\n), les apostrophes (\), les guillemets (\"). . . En Python, pour insrer
a
e
plus aisment des caract`res spciaux dans une cha
e
e
e
ne, sans faire usage de lantislash, ou pour
faire accepter lantislash lui-mme dans la cha on peut dlimiter la cha ` laide de triples
e
ne,
e
ne a
apostrophes (...) ou de triples guillemets ("""...""").
>>> s = cha^ne entre sur \
e
... plusieurs lignes
>>> s
cha^ne entre sur plusieurs lignes
e
>>> s = cha^ne entre \n sur 1 ligne
e
>>> print(s)
cha^ne entre
e
sur 1 ligne
>>> s = c\est a \"peuch`re\"

c
e
>>> s
c\est a "peuch`re"
c
e
>>> print(s)
cest a "peuch`re"
c
e
>>> s = a \ " \n z
>>> s
a \ \\ " \n z
TD4.4
TD 4.5 : Inverser une cha

ne
Dnir une fonction qui cre une copie dune cha en
e
e
ne
inversant lordre des caract`res.
e
>>> inverser(inverser)
resrevni
On acc`de aux caract`res individuels dune cha de caract`res par leur rang dans la cha
e
e
ne
e
ne,
un caract`re individuel tant vu lui-mme comme une cha ` un seul caract`re.
e
e
e
ne a
e
>>>
>>>
t
>>>
...
d e
s = des caract`res
e
s[9]
for c in s : print(c),
s
c a r a c t ` r e s
e
>>> s[4:9]
carac
>>> s[len(s)-1]
s
>>> s[:4] + mo + s[9] + s[-1]
des mots
TD4.5

4.2. SEQUENCES
165
Les cha
nes de caract`res, et leurs oprations associes, sont videmment tr`s utiles pour
e
e
e
e
e
manipuler du texte comme peut le faire un traitement de textes par exemple.
TD4.6
4.2.3
Listes
Dnition 4.8 : liste

e
Une liste est une squence modiable dlments.
e
ee
Dun point de vue syntaxique, une liste est une suite dlments spars par des virgules et
ee
e e
encadre par des crochets ([...]). On acc`de aux lments individuels dune liste comme pour
e
e
ee
une cha de caract`res ou un n-uplet mais, contrairement aux cha
ne
e
nes et aux n-uplets, on peut
modier chaque lment dune liste individuellement.
ee
>>>
>>>
5
>>>
7
>>>
...
1 3
s = [1,3,5,7]
s[2]
s[len(s)-1]
for c in s : print(c),
5 7
>>> s[1:3]
[3,5]
>>> s[1:3] = [2,4]
>>> s
[1, 2, 4, 7]
>>> s[len(s):len(s)] = [8,9]
>>> s
[1, 2, 4, 7, 8, 9]
Pour crer une liste, on peut explicitement le faire ` la main, comme ci-dessus avec linstruce
a
tion s = [1,3,5,7], mais ce nest raisonnable que pour de petites listes. On peut galement
e
utiliser la fonction prdnie range pour gn`rer une liste dentiers successifs (voir section 2.4.2
e e
e e
page 56). Si range est appele avec un seul argument, la liste contiendra un nombre de valeurs
e
gal ` largument fourni, en commenant ` partir de 0 (range(n) gn`re les nombres de 0 ` n-1 :
e
a
c
a
e e
a
[0,1,2,...,n-1]). On peut aussi utiliser range avec 2 ou 3 arguments : range(debut,fin,pas),
debut et pas tant optionnels. Largument debut est la premi`re valeur ` gnrer (debut = 0
e
e
a e e
par dfaut), largument pas est lincrment (pas = +1 par dfaut) qui permet de passer dune
e
e
e
valeur ` la suivante ([debut, debut + pas, debut + 2*pas,...]) et largument obligatoire
a
fin est la borne maximale (valeur fin exclue) des nombres ` gnrer.
a e e
range(5)
1, 2, 3, 4]
range(2,5)
3, 4]
>>>
[0,
>>>
[5,

LISTE n. f. XVIe si`cle. Emprunt de litalien lista,
e
e
de mme sens. Suite ordonne de noms, de mots, de
e
e
chires, de nombres, de symboles, etc.
TD 4.7 : Operations sur les listes (1)

tions sur les listes dcrites dans le tableau de la page 195.
e
TD4.7
>>>
[0,
>>>
[2,
`
TD 4.6 : Caracteres, mots, lignes dune cha
ne
Dnir une fonction qui compte le nombre de caract`res,
e
e
le nombre de mots et le nombres de lignes dune cha
ne
de caract`res.
e
range(0,5,2)
2, 4]
range(5,0,-2)
3, 1]
La fonction range est frquemment utilise dans les boucles pour rpter un nombre de fois
e
e
e e

166
TD 4.8 : Operations sur les listes (2)

Vrier que les oprations suivantes sont quivalentes
e
e
e
deux ` deux :
a
del s[i:j]
s.append(x)
s.extend(x)
s.insert(i,x)
s.remove(x)
s.pop(i)
et
et
et
et
et
et
s[i:j] = []
s[len(s):len(s)] = [x]
s[len(s):len(s)]= x
s[i:i] = [x]
del s[s.index(x)]
x = s[i] ; del s[i] ; return x

TD 4.9 : Selection delements
1. Dnir une fonction qui cre une liste t compose
e
e
e
des lments dune autre liste s qui vrient une
ee
e
certaine condition p (p(s[i]) == True).
2. Dnir une fonction qui supprime dune liste s les
e
lments qui ne vrient pas une certaine condiee
e
tion p.
Remarque 4.6 : En Python, linstruction spciale,

e
appele list comprehension :
e
t = [expression for element in sequence]
est quivalente ` :
e
a
t = []
t.append(expression)
Exemples :
>>> s = [1,2,3]
>>> s = [1,2,3]
>>> t = [c for c in s] >>> y = [c%2 for c in s]
>>> t
>>> y
[1, 2, 3]
[1, 0, 1]
connu ` lavance les instructions de la boucle. Mais dune mani`re plus gnrale, on utilisera les
a
e
e e
fonctions dajout (append) ou dinsertion (insert) dlments pour crer de nouvelles listes par
ee
e
programme.
On dispose en eet pour les listes des oprations prconises pour les collections (section
e
e
e
4.1.2 page 160) et que lon retrouve dans le tableau de la page 195 :
dterminer le nombre dlments de la liste s,
e
ee
len(s)
tester lappartenance dun lment x ` la liste s,
ee
a
x in s
ajouter un lment x ` la liste s,
ee
a
s.append(x)
et plus gnralement insrer un lment x au rang i dans la liste s,
e e
e
ee
s.insert(i,x)
supprimer llment de rang i de la liste s.
ee
del(s[i])
TD4.8
On dispose galement de quelques autres oprations particuli`rement ecaces telles que

e
e
e
compter les occurences (s.count(x)), retrouver le rang de la premi`re occurence dun lment
e
ee
(s.index(x)), inverser une liste (s.reverse()) ou trier une liste (s.sort()).
TD4.9
>>> s = [1,2,1,1,2]
>>> s.count(1)
3
>>> s.index(2)
1
>>>
>>>
[2,
>>>
[1,
s.reverse()
s
1, 1, 2, 1]
s.sort()
1, 1, 2, 2]
Comme nous lavons dj` voqu ` loccasion du passage des param`tres par rfrence lors
eae
ea
e
ee
de lappel dune fonction (section 3.3.1 page 115), le nom du liste est en fait une rfrence sur
ee
cette liste. Ainsi, si s est une liste, linstruction t = s ne fait que copier la rfrence de la liste
ee
et non la liste elle-mme : t devient un alias de s et toute modication dun lment de t (ou
e
ee
de s) modie galement s (ou t). Pour copier la liste, il faudra dune mani`re ou dune autre
e
e
copier les lments un par un, comme ci-dessous ` droite par exemple.
ee
a
>>>
>>>
>>>
>>>
[9,
>>>
[9,
s = [1,2,3]
t = s
t[0] = 9
t
2, 3]
s
2, 3]
>>>
>>>
>>>
>>>
[1,
>>>
>>>
[9,
>>>
[1,
s = [1,2,3]
t = []
t[:0] = s[0:]
t
2, 3]
t[0] = 9
t
2, 3]
s
2, 3]

4.2. SEQUENCES
4.2.4
167
Piles et les
Dans de nombreux cas, les seules oprations ` eectuer sur les listes sont des insertions et
e
a
des suppressions aux extrmits de la liste. Cest le cas en particulier des piles (stack) et des
e
e
les (queue).
Exemple 4.5 : Pile dassiettes
Dans une pile dassiettes (gure 4.11), on ajoute des assiettes au sommet de la pile, et on les
rcup`re dans lordre inverse, en commenant par la derni`re ajoute.
e
e
c
e
e

FILE n. f. XVe si`cle. Dverbal de ler. Suite de
e
e
personnes ou de choses places les unes derri`re les
e
e
autres sur une mme ligne.
e
PILE n. f. Ensemble dobjets de mme sorte placs
e
e
les uns sur les autres.
Dnition 4.9 : pile

e
Une pile est une squence dans laquelle on ne peut ajouter et supprimer un lment qu` une
e
ee
a
seule extrmit : le sommet de la pile.
e e
Fig. 4.11 : Piles dassiettes
Dans le cas des piles, on ajoute (on empile) et on supprime (on dpile) ` une seule extrmit.
e
a
e e
Une pile est ainsi base sur le principe dernier arriv, premier sorti (Lifo : Last In, First
e
e
Out) : le dernier lment ajout au sommet de la pile sera le premier ` tre rcupr. Les seules
ee
e
ae
e
ee
oprations ncessaires pour une pile sont ainsi :
e
e
tester si la pile p est vide,
ok = emptyStack(p)
accder au sommet x de la pile p,
e
x = topStack(p)
empiler un lment x au sommet de la pile p,
ee
pushStack(p,x)
dpiler llment x qui se trouve au sommet de la pile p.
e
ee
x = popStack(p)
Fig. 4.12 : Files dattente a un peage
TD4.10
Exemple 4.6 : File dattente de voitures

A un page (gure 4.12), la premi`re voiture ` tre entre dans une le dattente sera la premi`re
e
e
ae
e
e
sortie de la le.
Dnition 4.10 : file
e
Une le est une squence dans laquelle on ne peut ajouter un lment qu` une seule extrmit
e
ee
a
e e
et ne supprimer un lment qu` lautre extrmit : la tte de la le.
ee
a
e e
e
Dans le cas des les, on ajoute (on enle) ` une extrmit et on supprime (on dle) ` lautre
a
e
e
e
a
extrmit. Une le est ainsi base sur le principe premier arriv, premier sorti (Fifo : First
e e
e
e
In, First Out) : le premier lment ajout sera le premier ` tre rcupr en tte de le.
ee
e
ae
e
ee
e

168
TD 4.10 : Operations sur les piles

Dnir les 4 oprations sur les piles dnies ci-contre :
e
e
e
emptyStack, topStack, pushStack et popStack. On empilera et dpilera ` la n de la liste qui sert ` stocker les
e
a
a
lments de la pile.
ee
TD 4.11 : Operations sur les files

Dnir les 4 oprations sur les les dnies ci-contre :
e
e
e
emptyQueue, topQueue, pushQueue et popQueue. On enlera en dbut de liste et on dlera ` la n de la liste
e
e
a
qui sert ` stocker les lments de la le.
a
ee

MATRICE n. f. XIIIe si`cle. Emprunt du latin mae
e
trix, matricis, reproductrice , driv de mater,
e e
m`re . MATH. Ensemble ordonn de nombres
e
e
algbriques, prsent sous forme de tableau. Les die
e
e
mensions dune matrice, le nombre de lignes et de
colonnes qui constituent le tableau. Matrice carre,
e
qui a le mme nombre de lignes et de colonnes.
e
Fig. 4.14 : Echiquier
Les seules oprations ncessaires pour une le sont ainsi :

e
e
tester si la le f est vide,
accder ` la tte x de la le f,
e
a
e
enler un lment x dans la pile f,
ee
dpiler llment x qui se trouve en tte de la le f.
e
ee
e
ok = emptyQueue(f)
x = topQueue(f)
pushQueue(f,x)
x = popQueue(f)
TD4.11
4.2.5
Listes multidimensionnelles
Un autre cas particulier de liste est celui o` les lments dune liste sont eux-mmes des listes.
u
ee
e
On parle alors de listes de listes (ou de tableaux de tableaux) ou de listes multidimensionnelles
(ou de tableaux multidimensionnels). Un damier, une image numrique ou encore une matrice
e
(gure 4.13) sont des exemples de tableaux bidimensionnels.
Dans lexemple ci-dessous, la liste s est compos de 3 listes (len(s) == 3) de longueurs
e
direntes. Un premier niveau de crochets donne acc`s ` un lment de la liste s (comme s[2]
e
e a
ee
par exemple) : cet lment est lui-mme une liste (la liste [6,7,8,9]) ; un deuxi`me niveau de
ee
e
e
crochets donne acc`s ` un lment de cette liste (comme s[2][1] par exemple). Dune mani`re
e a
ee
e
gnrale, il faudra autant de niveaux de crochets que de listes imbriques pour accder aux
e e
e
e
lments individuels.
ee
>>> s = [[4,5],[1,2,3],[6,7,8,9]]
>>> type(s)
<type list>
>>> len(s)
3
>>> type(s[2])
<type list>
>>>
[6,
>>>
7
>>>
3
s[2]
7, 8, 9]
s[2][1]
s[1][2]
Exemple 4.7 : Echiquier

Lchiquier de la gure 4.14 ci-contre est un ensemble de 8 lig nes (numrotes de 1 ` 8 sur
e
e e
a
la gure) composes chacune de 8 cases (nommes de A ` H). Il peut tre reprsent par une
e
e
a
e
e
e
liste s de 8 listes, chacune compose de 8 lments. Ainsi, le roi blanc (en 8G sur la gure) sera
e
ee
llment s[7][6] et le cavalier blanc (en 4D) sera llment s[3][3] de la liste s en tenant
ee
ee
compte de la convention informatique qui fait dbuter ` 0 les indices dune liste.
e
a
Le parcours dun tableau bidimensionnel ncessite 2 boucles imbriques : la premi`re pour
e
e
e

4.2. SEQUENCES
169
accder aux lignes les unes apr`s les autres, la deuxi`me pour accder aux lments individuels
e
e
e
e
ee
de chaque ligne.
>>>
>>>
...
[4,
[1,
[6,
s = [[4,5],[1,2,3],[6,7,8,9]]
for c in s : print(c)
5]
2, 3]
7, 8, 9]
>>>
[6,
>>>
...
...
...
4 5
1 2
6 7
s[2]
7, 8, 9]
for c in s :
for e in c : print(e,end= )
print()
3
8 9
Dune mani`re gnrale, il faudra autant de boucles imbriques quil y a de listes imbriques
e
e e
e
e
pour parcourir lensemble des lments individuels.
ee
>>> s = [[[4,5],[1,2,3]], [[0],[10,11],[6,7,8,9]]]
>>> len(s)
2
>>> len(s[1])
3
>>> len(s[1][2])
4
>>> s[1][2][2]
8
>>> for c in s : print(c)
...
[[4, 5], [1, 2, 3]]
[[0], [10, 11], [6, 7, 8, 9]]
>>> for c in s :
...
for e in c : print(e),
...
print()
...
[4, 5] [1, 2, 3]
[0] [10, 11] [6, 7, 8, 9]
>>> for c in s :
...
for e in c :
...
for x in e :
print(x,end= )
...
print()
...
4 5 1 2 3
0 10 11 6 7 8 9
Un cas particulier important de liste multidimensionnelle est la notion de matrice. En

mathmatiques, les matrices servent ` interprter en termes calculatoires et donc opratione
a
e
e
nels les rsultats thoriques de lalg`bre linaire [8]. On reprsente gnralement une matrice A
e
e
e
e
e
e e
sous la forme dun tableau rectangulaire de n lignes et de m colonnes :
a00
a01
a0(m2)
a0(m1)
a10
a11
a1(m2)
a1(m1)
A = (aij ) =

a(n1)0 a(n1)1 a(n1)(m2) a(n1)(m1)
La matrice est dite carre quand n = m et symtrique quand i, j aij = aji .
e
e
Remarque 4.7 : Les n lignes dune matrice de dimensions (n, m) ont toutes la mme longueur m contrairee
ment au cas plus gnral des listes multidimensionnelles
e e
qui peuvent avoir des lignes de direntes longueurs.
e

170
En informatique, une matrice sera simplement reprsente par un tableau bidimensionnel

e
e
comme la matrice de dimensions (n = 2, m = 3) ci-dessous.
>>> s = [[1,2,3],[4,5,6]]
>>> n = len(s)
>>> m = len(s[0])
>>> len(s[0]) == len(s[1])
True
TD 4.12 : Produit de matrices
Dnir la fonction qui calcule la matrice C, produit de 2
e
matrices A et B respectivement de dimensions (n, r) et
(r, m).
r1
X
cij =
aik bkj
>>> n
2
>>> m
3
Exemple 4.8 : Addition de 2 matrices

Laddition de 2 matrices A et B de mmes dimensions (n, m) donne une nouvelle matrice C de
e
dimensions (n, m) telle que cij = aij + bij .
def additionMatrice(a,b):
n, m = len(a), len(a[0])
s = []
for i in range(n):
c = []
for j in range(m):
c.append(a[i][j]+b[i][j])
s.append(c)
return s
k=0
>>> a = [[1,2,3],[4,5,6]]
>>> b = [[-1,-2,-3],[-1,-2,-3]]
>>> additionMatrice(a,b)
[[0, 0, 0], [3, 3, 3]]
>>> additionMatrice(a,a)
[[2, 4, 6], [8, 10, 12]]
A
TD4.12
Les matrices sont utilises pour de multiples applications et servent notamment ` reprsenter
e
a
e
les coecients des syst`mes dquations linaires (voir TD 4.29 page 184 et annexe 4.6.5 page
e
e
e
199).
4.3
Remarque 4.8 : Lopration de recherche est tellee
ment importante quelle est aujourdhui toujours disponible dans les syst`mes dexploitation et dans les langages
e
de programmation. En Python, la mthode index eece
tue cette recherche pour les cha
nes et pour les listes. Il
est donc rarement ncessaire de la rdnir soi-mme ;
e
e e
e
nous le faisons ici pour des raisons pdagogiques.
e
Recherche dans une squence

e
En informatique, une des oprations essentielles est de retrouver une information stocke en
e
e
mmoire vive, sur un disque dur ou quelque part sur le rseau. Il sut pour sen convaincre
e
e
de penser au nombre de fois dans la journe o` lon recherche un numro de tlphone sur son
e u
e
ee
portable ou une information quelconque sur internet ` laide dun moteur de recherche.
a
Nous nous intresserons ici ` 2 mthodes de recherche dun lment dans une liste : la
e
a
e
ee
recherche squentielle et la recherche dichotomique.
e

4.3. RECHERCHE DANS UNE SEQUENCE
4.3.1
171
Recherche squentielle
e
La recherche squentielle dun lment x dans une liste t consiste ` comparer llment
e
ee
a
ee
recherch x successivement ` tous les lments de la liste t jusqu` trouver une correspondance.
e
a
ee
a
Autrement dit, on compare llment recherch x au premier lment de la liste t. Sils sont
ee
e
ee
identiques, on a trouv le rang de la premi`re occurence de x dans t ; sinon, on recommence la
e
e
recherche ` partir du deuxi`me lment. Et ainsi de suite. . . On en dduit la version rcursive
a
e
ee
e
e
ci-dessous gnralise ` une recherche entre deux rangs debut et fin de la liste t. Dans cette
e e
e a
version, nous avons choisi de retourner un couple de valeurs (ok,r) : ok est un boolen qui
e
teste si la recherche est fructueuse ou non et r est le rang de la premi`re occurence de llment
e
ee
recherch sil a eectivement t trouv.
e
ee
e
def recherche(t,x,debut,fin):
ok,r = False,debut
if r > fin: ok = False
else:
if t[r] == x: ok = True
else: ok,r = recherche(t,x,r+1,fin)
return ok,r
>>> s = [1,3,5,6,5,2]
>>> recherche(s,5,0,len(s)-1)
(True, 2)
(True, 4)
(False, 6)
TD4.13
La version itrative quivalente est donne ci-dessous en prcisant les prconditions dutilie
e
e
e
e
sation de lalgorithme.
e
1
2
3
4
5
6
7
8
def rec h e r c h e S e q u e n t i e l l e (t ,x , debut , fin ):

assert type ( t ) is list
assert 0 <= debut <= fin < len ( t )
ok , r = False , debut
while r <= fin and not ok :
if t [ r ] == x : ok = True
else : r = r + 1
return ok , r
Le nombre ditrations eectues pour retrouver x est gal ` la longueur n de la liste t si x

e
e
e
a
nest pas dans la liste et ` r, rang de la premi`re occurence de x, si x est dans la liste. Ainsi,
a
e
si on dnit la complexit c de cet algorithme comme le nombre ditrations eectues, elle est
e
e
e
e

TD 4.13 : Annuaire telephonique
On consid`re un annuaire tlphonique stock sous la
e
ee
e
forme dune liste de couples (nom,tlphone) (exemple :
e e
[(jean,0607080910),(paul,0298000102)]).
1. Dnir une fonction qui retrouve dans un ane
nuaire tlphonique le numro de tlphone ` paree
e
ee
a
tir du nom.
2. Dnir la fonction inverse qui retrouve le nom `
e
a
partir du numro de tlphone.
e
ee

172
Remarque 4.9 : On dnit la complexit dun algoe

e
rithme A comme une fonction fA (n) de la taille n des
donnes. Pour analyser cette complexit, on sattache `
e
e
a
dterminer lordre de grandeur asymptotique de fA (n) :
e
on cherche une fonction connue qui a une rapidit de
e
croissance voisine de celle de fA (n). On utilise pour cela
la notation mathmatique f = O(g), qui se lit f est en
e
grand O de g , et qui indique avec quelle rapidit une
e
fonction augmente ou diminue . Ainsi f = O(g)
signie que lordre de grandeur asymptotique de f est
infrieur ou gal ` celui de g.
e
e
a
Notation
O(1)
O(log(n))
O(n)
O(n log(n))
O(n2 )
O(n3 )
O(np )
O(nlog(n) )
O(2n )
O(n!)
Type de complexit
e
complexit constante
e
complexit logarithmique
e
complexit linaire
e
e
complexit quasi-linaire
e
e
complexit quadratique
e
complexit cubique
e
complexit polynomiale
e
complexit quasi-polynomiale
e
complexit exponentielle
e
complexit factorielle
e
Remarque 4.10 : Sauf mention contraire, une liste

trie le sera ici selon lordre croissant de ses lments.
e
ee
TD 4.14 : Recherche dichotomique
La recherche dichotomique prsente ci-contre nassure
e
e
pas de trouver la premi`re occurence dun lment x dans
e
ee
une liste t trie.
e
Modier lalgorithme de recherche dichotomique propos
e
pour rechercher la premi`re occurence dun lment x
e
ee
dans une liste t trie.
e
au pire gale ` n, au mieux gale ` 1. En moyenne, on peut dmontrer (voir [9] ou [12]) quelle
e
a
e
a
e
vaut (1 q) n + (n + 1) q/2 si q est la probabilit que x soit dans t, quelle que soit sa position
e
dans la liste (toutes les places sont quiprobables). On retrouve bien c = n si q = 0. On a
e
galement c = (n + 1)/2 si q = 1 et c = (3n + 1)/4 si q = 1/2. Dans tous les cas, lordre de
e
grandeur de la complexit de la recherche squentielle est n, le nombre dlments dans la liste :
e
e
ee
on parle alors de complexit linaire, note O(n). Il sagit dune recherche linaire en fonction
e e
e
e
du nombre dlments dans la liste : si le nombre dlments est multipli par 100, le complexit
ee
ee
e
e
sera multiplie par 100 en moyenne, et donc le temps dexcution de la recherche galement.
e
e
e
4.3.2
Recherche dichotomique
Dans certains cas, la recherche dun lment x seectue dans une liste t trie. La mthode
ee
e
e
qui suit, dite recherche par dichotomie ou recherche dichotomique, utilise pleinement le fait que
les lments de la liste sont tris.
ee
e
Le principe de la recherche dichotomique consiste ` comparer x avec llment t[m] du milieu
a
ee
de la liste t :
si x == t[m], on a trouv une solution et la recherche sarrte ;
e
e
si x < t[m], x ne peut se trouver que dans la moiti gauche de la liste t puisque celle-ci est
e
trie par ordre croissant ; on poursuit alors la recherche de la mme mani`re uniquement
e
e
e
dans la moiti gauche de la liste ;
e
si x > t[m], x ne peut se trouver que dans la moiti droite de la liste t ; on poursuit alors
e
la recherche uniquement dans la moiti droite de la liste.
e
A chaque fois, on poursuit donc la recherche en diminuant de moiti le nombre dlments restant
e
ee
a
` traiter. En suivant ce principe de recherche, on est naturellement amen ` crire une version
eae
rcursive de lalgorithme de recherche dichotomique.
e
def dichotomie(t,x,gauche,droite):
ok, m = False, (gauche + droite)/2
if gauche > droite: ok = False
else:
if t[m] == x: ok = True
elif t[m] > x:
ok,m = dichotomie(t,x,gauche,m-1)
else:
ok,m = dichotomie(t,x,m+1,droite)
return ok,m
>>> s = [1,3,5,6,6,9]
>>> dichotomie(s,6,0,len(s)-1)
(True, 4)
(True, 3)
(False, 1)
TD4.14

4.4. TRI DUNE SEQUENCE
173
La version itrative quivalente est donne ci-dessous en prcisant les prconditions dutilie
e
e
e
e
sation de lalgorithme.
1
2
3
4
5
6
7
8
9
10
def rec h e r c h e D i c h o t o m i q u e (t ,x , gauche , droite ):

assert 0 <= gauche <= droite < len ( t )
ok , m = False , ( gauche + droite )/2
while gauche <= droite and not ok :
m = ( gauche + droite )/2
if t [ m ] == x : ok = True
elif t [ m ] > x : droite = m - 1
else : gauche = m + 1
return ok , m
4.4
Tri dune squence

e
Pour retrouver une information, il est souvent plus ecace que les donnes soient pralae
e
blement tries : cest ce que nous avons constat avec la recherche par dichotomie de la section
e
e
prcdente. L` encore, pour sen convaincre, il sut de penser ` la recherche dun mot dans un
e e
a
a
dictionnaire ou dun nom dans un bottin.
Dans la suite, nous supposerons quil existe une relation dordre total, entre les lments
ee
de la liste, note et qui vrie les proprits habituelles de rexivit, dantisymtrie et de
e
e
ee
e
e
e
transitivit :
e
1. rexivit : x x
e
e
2. antisymtrie : (x y) and (y x) x = y
e
3. transitivit : (x y) and (y z) (x z)
e
La fonction rcursive enOrdre ci-dessous teste si la liste t est trie par ordre croissant de
e
e
ses lments entre les rangs debut et fin, en utilisant la relation dordre <= (t[debut] <=
ee
t[debut+1]).
Remarque 4.11 : On peut montrer (voir [9] ou [12])

que la complexit de lalgorithme de recherche dichotoe
mique est de lordre de log(n) o` n est la longueur de
u
la liste. Il sagit dune complexit logarithmique (voir ree
marque 4.9 page 172).

174
def enOrdre(t,debut,fin):
assert type(t) is list
assert 0 <= debut <= fin < len(t)
ok = False
if debut == fin: ok = True
else:
if t[debut] <= t[debut+1]:
ok = enOrdre(t,debut+1,fin)
return ok
TD 4.15 : Liste ordonnee

Dnir une version itrative de la fonction rcursive
e
e
e
enOrdre dnie ci-contre. On appliquera la mthode de
e
e
transformation dcrite en section 3.3.4 page 127.
e
TD4.15
Nous nous intresserons ici ` 3 mthodes de tri dune liste : le tri par slection, le tri par
e
a
e
e
insertion et le tri rapide.
4.4.1
Fig. 4.15 : Tri par selection

?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
y
Tri de la liste
[6,4,1,3,5,2] :
en gras, les valeurs
changes ` chaque
e
e
a
tape.
e

TD 4.16 : Tri dun annuaire telephonique
On consid`re un annuaire tlphonique stock sous la
e
ee
e
forme dune liste de couples (nom,tlphone) (exemple :
e e
[(paul,0607080910),(jean,0298000102)]).
Dnir une fonction qui trie un annuaire tlphonique
e
ee
par ordre alphabtique des noms.
e
>>> s = [3,1,2,3,1]
>>> enOrdre(s,0,len(s)-1)
False
>>> enOrdre(s,1,3)
True
>>> enOrdre(s,1,4)
False
Tri par slection

e
Le tri par slection dune liste consiste ` rechercher le minimum de la liste ` trier, de le
e
a
a
mettre en dbut de liste en lchangeant avec le premier lment et de recommencer sur le reste
e
e
ee
de la liste (gure 4.16). La version rcursive ci-dessous trie la liste t par ordre croissant entre
e
les rangs debut et fin ; elle fait appel ` la fonction minimum qui retourne le rang du plus petit
a
lment de la squence t entre les rangs debut et fin.
ee
e
def triSelection(t,debut,fin):
if debut < fin:
mini = minimum(t,debut,fin)
t[debut],t[mini] = t[mini],t[debut]
triSelection(t,debut+1,fin)
return
def minimum(t,debut,fin):
mini = debut
for j in range(debut+1,fin+1):
if t[j] < t[mini]: mini = j
return mini
>>>
>>>
>>>
[0,
>>>
>>>
5
>>>
0
>>>
3
s = [5,4,3,2,1,0]
triSelection(s,0,len(s)-1)
s
1, 2, 3, 4, 5]
s = [5,4,3,2,1,0]
minimum(s,0,len(s)-1)
s[minimum(s,0,len(s)-1)]
s[minimum(s,0,2)]
TD4.16
On en dduit la version itrative quivalente :

e
e
e

175
Tri par slection
e
1
2
3
4
5
6
7
8
def triSelection (t , debut , fin ):

while debut < fin :
mini = minimum (t , debut , fin )
t [ debut ] , t [ mini ] = t [ mini ] , t [ debut ]
debut = debut + 1
return
TD4.17
TD 4.17 : Complexite du tri par selection

Montrer que la complexit du tri par slection est :
e
e
1. en O(n) en ce qui concerne les changes de valeurs
e
au sein dune liste de longueur n,
4.4.2
2. en O(n2 ) en ce qui concerne les comparaisons

entre lments de la liste.
ee
Tri par insertion
`
Dans le tri par insertion, on trie successivement les premiers lments de la liste : ` la ieme
ee
a
eme lment ` son rang parmi les i 1 lments prcdents qui sont dj` tris
`
tape, on ins`re le i
e
e
ee
a
ee
e e
ea e
entre eux. Dans la version rcursive de la fonction triInsertion, on ins`re llment t[fin]
e
e
ee
dans la liste des lments prcdents dj` trie de debut ` (fin - 1).
ee
e e
ea e
a
def triInsertion(t,debut,fin):
if fin > debut:
triInsertion(t,debut,fin-1)
i = fin - 1
x = t[fin]
while i >= debut and t[i] > x:
t[i+1] = t[i]
i = i - 1
t[i+1] = x
return
>>>
>>>
>>>
[4,
>>>
>>>
>>>
[9,
s = [9,8,7,6,5,4]
triInsertion(s,0,len(s)-1)
s
5, 6, 7, 8, 9]
s = [9,8,7,6,5,4]
triInsertion(s,1,4)
s
5, 6, 7, 8, 4]
La procdure prcdente nest pas rcursive terminale et on ne peut donc pas utiliser la
e
e e
e
mthode de la section 3.3.4 page 127 pour la transformer en procdure itrative. Considrons
e
e
e
e
alors une procdure rcursive non terminale du type :
e
e
Fig. 4.16 : Tri par insertion

?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
y
Tri de la liste
[6,4,1,3,5,2] :
insres dans la pare e
tie gauche ` chaque
a
tape.
e
Remarque 4.12 : Le tri par insertion correspond ` la

a
stratgie dun joueur de cartes qui trie son jeu.
e

176
def f(x):
instruction_1
f(g(x))
instruction_2
return
TD 4.18 : Tri par insertion

Excuter ` la main lappel
e
a
triInsertion([9,8,7,6,5,4],1,4)
en donnant les valeurs des variables i, k, x et t ` la n de
a
chaque itration de la boucle while (ligne 7 de la version
e
itrative de lalgorithme).
e
x reprsente ici la liste des arguments de la fonction, instruction 1 et

e
e
instruction 2 des blocs dinstructions qui encadrent lappel rcursif f(g(x))
et g(x) une transformation des arguments de f. La fonction triInsertion
est bien de ce type : x = t,debut,fin, instruction 1 est vide, g(x) :
t,debut,fin t,debut,fin-1 et instruction 2 regroupe toutes les instructions qui suivent lappel rcursif.
e
La mthode consiste ` sauvegarder, ` la n de lexcution de instruction 1, la valeur de x

e
a
a
e
sur une pile (voir section 4.2.4 page 167). Puis on excute lappel rcursif, et on restaure la valeur
e
e
de x (on dpile x) avant dexcuter instruction 2. Pour un appel triInsertion(t,debut,fin),
e
e
on va empiler successivement fin, fin-1, fin-2, . . . ,debut+1 (seul fin volue lors des appels),
e
puis on rcup`rera sur la pile les valeurs en sens inverse debut+1, debut+2, . . . ,fin-2, fin-1 et
e
e
fin pour chacune desquelles on excutera la n de la procdure. Une simple boucle for k in
e
e
range(debut+1,fin+1) permettra de simuler cette rcupration.
e
e
La version itrative ci-dessous est quivalente ` la procdure rcursive. On retrouve des lignes
e
e
a
e
e
5 ` 10 les instructions qui suivent lappel rcursif de la version rcursive ; la boucle de la ligne
a
e
e
4 simule la rcupration des valeurs successives de largument fin sauvegardes avant lappel
e
e
e
rcursif.
e
Tri par insertion
1
2
3
4
5
6
7
8
9
10
11
def triInsertion (t , debut , fin ):

for k in range ( debut +1 , fin +1):
i = k - 1
x = t[k]
while i >= debut and t [ i ] > x :
t [ i +1] = t [ i ]
i = i - 1
t [ i +1] = x
return
TD4.18
O(n2 )
On peut dmontrer que la complexit du tri par insertion est en

e
e
aussi bien en ce qui
concerne les changes de valeurs au sein de la liste que les comparaisons entre lments de la
e
ee
liste.

4.4.3
177
Tri rapide
Les complexits des tris par slection et par insertion sont, soit en nombre dchanges de
e
e
e
valeurs, soit en nombre de comparaisons entre lments, quadratiques en O(n2 ). La mthode de
ee
e
tri rapide (quicksort) prsente ici a une complexit quasi-linaire en O(n log(n)).
e
e
e
e
Le principe du tri rapide est le suivant : on partage la liste ` trier en deux sous-listes telles que
a
tous les lments de la premi`re soient infrieurs ` tous les lments de la seconde. Pour partager
ee
e
e
a
ee
la liste en deux sous-listes, on choisit un des lments de la liste (par exemple le premier) comme
ee
pivot. On construit alors une sous-liste avec tous les lments infrieurs ou gaux ` ce pivot et
ee
e
e
a
une sous-liste avec tous les lments suprieurs au pivot (gure 4.17). On trie les deux sous-listes
ee
e
selon le mme processus jusqu` avoir des sous-listes rduites ` un seul lment (gure 4.18).
e
a
e
a
ee
def triRapide(t,debut,fin):
assert 0 <= debut
assert fin <= len(t)
if debut < fin:
pivot = t[debut]
place = partition(t,debut,fin,pivot)
triRapide(t,debut,place-1)
triRapide(t,place+1,fin)
return
>>>
>>>
>>>
[4,
>>>
>>>
>>>
[9,
s = [9,8,7,6,5,4]
triRapide(s,0,len(s)-1)
s
5, 6, 7, 8, 9]
s = [9,8,7,6,5,4]
triRapide(s,1,4)
s
5, 6, 7, 8, 4]
def partition(t,debut,fin,pivot):
p,inf,sup = debut,debut,fin;
while p <= sup:
if t[p] == pivot:
p = p + 1
elif t[p] < pivot:
t[inf],t[p] = t[p],t[inf]
inf = inf + 1
p = p + 1
else:
t[sup],t[p] = t[p],t[sup]
sup = sup - 1
if p > 0: p = p - 1
return p
>>> s = [3,5,2,6,1,4]
>>> partition(s,0,len(s)-1,s[0]), s
(2, [1, 2, 3, 6, 5, 4])
Pour partitionner la liste, on a utilis 2 compteurs inf et sup qui partent des 2 extrmits de la
e
e
e
liste en voluant lun vers lautre. Le compteur de gauche inf part du dbut de la liste et lorsquil
e
e
atteint un lment suprieur au pivot, on arrte sa progression. De mme, le compteur de droite
ee
e
e
e
sup part de la n de la liste et sarrte lorsquil atteint un lment infrieur au pivot. On change
e
ee
e
e
alors ces deux lments (t[sup],t[inf] = t[inf],t[sup]) puis on continue ` faire progresser
ee
a
les compteurs et ` faire des changes jusqu` ce que les compteurs se croisent.
a
e
a
Ainsi, le tri rapide correspond au schma rcursif suivant :
e
e
Remarque 4.13 : Le tri rapide est une mthode de tri

e
invente par Charles Antony Richard Hoare en 1961 et
e
base sur le principe diviser pour rgner. Cest en prae
e
tique un des tris sur place le plus rapide pour des donnes
e
rparties alatoirement.
e
e
Fig. 4.17 : Partition dune liste

ti pivot
pivot
ti > pivot
La partition dune liste est une variante du

probl`me du drapeau hollandais d ` linformatie
u a
cien nerlandais Edsger Wybe Dijkstra. Dans
e
sa version originale, on remplit alatoirement un
e
tableau avec les couleurs bleu, blanc et rouge. Le
probl`me consiste ` trouver un algorithme qui, par
e
a
des changes successifs de composantes, reconstitue
e
le drapeau hollandais. Lalgorithme ne doit pas utiliser de tableau intermdiaire et ne parcourir le tae
bleau quune seule fois.
Fig. 4.18 : Tri rapide

?
?
?
?
?
?
?
?
?
?
?
y
Tri de la liste
[6,4,1,3,5,2] :
des pivots ` chaque
a
tape.
e

178
def f(x):
if cond:
instructions
f(g(x))
f(h(x))
return
x reprsente ici la liste des arguments de la fonction, cond une condition

e
portant sur x, instructions un bloc dinstructions qui prc`de les 2 appels
e e
rcursifs f(g(x)) et f(h(x)). g(x) et h(x) sont des transformations des argue
ments de f. Dans le cas du tri rapide, on a g(x) : fin = place - 1 et h(x) :
debut = place + 1.
`
On peut supprimer le 2eme appel rcursif (f(h(x))), qui est terminal, selon la mthode expose
e
e
e
en section 3.3.4 page 127. Ce qui donne :
def f(x):
while cond:
instructions
f(g(x))
x = h(x)
return
assert 0 <= debut
while debut < fin:
pivot = t[debut]
triRapide(t,debut,place-1)
debut = place + 1
return
e
e
La suppression du 1er appel rcursif (f(g(x))) est moins immdiate car cet appel nest pas
terminal et la valeur des arguments x ne varie pas de mani`re aussi prvisible que pour le tri par
e
e
insertion (voir section 4.4.2 page 175). Comme suggr en section 4.4.2 page 176, on peut utiliser
ee
une pile pour sauvegarder les contextes dappel de la premi`re rcursivit (empiler(pile,x))
e
e
e
avant de les restaurer pour la deuxi`me rcursivit (x = depiler(pile)) :
e
e
e
def f(x):
pile = []
while True:
while cond:
instructions
empiler(pile,x)
x = g(x)
if not len(pile) == 0:
x = depiler(pile)
x = h(x)
else: return
return
def empiler(p,x):
assert type(p) is list
p.append(x)
return
def depiler(p):
assert type(p) is list
assert len(p) > 0
x = p[len(p)-1]
del p[len(p)-1]
return x

179
Ce qui donne la version itrative suivante pour le tri rapide :

e
assert 0 <= debut
pile = []
while True:
while debut < fin:
pivot = t[debut]
empiler(pile,(debut,fin,place))
fin = place - 1
if not len(pile) == 0:
(debut,fin,place) = depiler(pile)
debut = place + 1
else: return
return
>>>
>>>
>>>
[4,
>>>
>>>
>>>
[9,
s = [9,8,7,6,5,4]
triRapide(s,0,len(s)-1)
s
5, 6, 7, 8, 9]
s = [9,8,7,6,5,4]
triRapide(s,1,4)
s
5, 6, 7, 8, 4]
A notre niveau, on retiendra cependant la version rcursive, plus proche de la description du tri
e
rapide :
Tri rapide
1
2
3
4
5
6
7
8
9
10
def triRapide (t , debut , fin ):

assert 0 <= debut
assert fin <= len ( t )
if debut < fin :
pivot = t [ debut ]
place = partition (t , debut , fin , pivot )
triRapide (t , debut , place -1)
triRapide (t , place +1 , fin )
return
TD4.19
TD 4.19 : Comparaison dalgorithmes (1)

Comparer les temps dexcution des versions rcursive et
e
e
itrative du tri rapide pour direntes tailles de liste.
e
e
On pourra utiliser la fonction random() ou
randint(min,max) du module standard random pour
gnrer des listes de nombres alatoires, et la fonction
e e
e
time() du module standard time pour mesurer le temps
avant et apr`s lappel des fonctions.
e

180
4.5
4.5.1
e
Conna
tre
TD 4.20 : QCM (4)

1. Le type dune variable dnit
e
(a) lensemble des noms quelle peut prendre.
(b) le regroupement ni des donnes qui la composent et dont le nombre nest pas x a
e
e
priori.
(c) lensemble des valeurs quelle peut prendre et lensemble des oprations quelle peut
e
subir.
(d) le regroupement hirarchique des donnes qui la composent
e
e
2. Une squence est
e
(a) un regroupement ni de donnes dont le nombre nest pas x a priori.
e
e
(b) une collection dlments, appels sommets , et de relations entre ces sommets.
ee
e
(c) une collection non ordonne dlments.
e
ee
(d) une suite ordonne dlments accessibles par leur rang dans la squence.
e
ee
e
3. Parmi les exemples suivants, le seul exemple de squence est
e
(a) le tableau nal dun tournoi de tennis.
(b) la carte routi`re.
e
(c) la classication des esp`ces animales.
e
(d) la main au poker.
4. Parmi les types suivants, un seul nest pas une variante de squence. Lequel ?
e
(a) le n-uplet.
(b) la cha de caract`res.
ne
e
(c) le dictionnaire.
(d) la pile.
5. Dans une liste

181
(a) tous les lments sont du mme type.

ee
e
(b) les lments peuvent avoir des types dirents.
ee
e
(c) les lments ne peuvent pas tre des dictionnaires.
ee
e
(d) les lments ont comme type un des types de base (bool,int,float).
ee
6. Dans la liste multidimensionnelle s = [[1,2,3,4],[5,6,7],[8,9]] que vaut s[1][1] ?
(a) 1.
(b) 2.
(c) 5.
(d) 6.
7. Une pile est une squence dans laquelle
e
(a) on ne peut ajouter un lment qu` une seule extrmit et ne supprimer un lment
ee
a
e e
ee
qu` lautre extrmit.
a
e e
(b) on ne peut ajouter un lment qu` une seule extrmit et en supprimer nimporte o`.
ee
a
e e
u
(c) on ne peut ajouter et supprimer un lment qu` une seule extrmit.
ee
a
e e
(d) on ne peut supprimer un lment qu` une seule extrmit et en ajouter nimporte o`.
ee
a
e e
u
8. Une le est une squence dans laquelle
e
(a) on ne peut ajouter un lment qu` une seule extrmit et ne supprimer un lment
ee
a
e e
ee
qu` lautre extrmit.
a
e e
(b) on ne peut ajouter un lment qu` une seule extrmit et en supprimer nimporte o`.
ee
a
e e
u
(c) on ne peut ajouter et supprimer un lment qu` une seule extrmit.
ee
a
e e
(d) on ne peut supprimer un lment qu` une seule extrmit et en ajouter nimporte o`.
ee
a
e e
u
9. La recherche squentielle dun lment dans une liste consiste `
e
ee
a
(a) rechercher le minimum de la liste et ` le mettre en dbut de liste en lchangeant avec
a
e
e
cet lment.
ee
(b) rechercher le maximum de la liste et ` le mettre en dbut de liste en lchangeant avec
a
e
e
cet lment.
ee
(c) comparer llment recherch successivement ` tous les lments de la liste jusqu`
ee
e
a
ee
a
trouver une correspondance.

182
(d) comparer llment recherch avec llment milieu de la liste et poursuivre de mme
ee
e
ee
e
dans la sous-liste de droite ou dans la sous-liste de gauche ` llment milieu.
a ee
10. Dans le tri par insertion
(a) on partage la liste ` trier en deux sous-listes telles que tous les lments de la premi`re
a
ee
e
soient infrieurs ` tous les lments de la seconde, puis on trie les deux sous-listes
e
a
ee
selon le mme processus jusqu` avoir des sous-listes rduites ` un seul lment.
e
a
e
a
ee
`
(b) on trie successivement les premiers lments de la liste : ` la ieme tape, on place le
ee
a
e
eme lment ` son rang parmi les i 1 lments prcdents qui sont dj` tris entre
`
i
ee
a
ee
e e
ea e
eux.
Remarque 4.14 : Parmi les 4 items de la question cicontre, un seul item dnit le tri par insertion, les 3
e
autres dnissent dautres mthodes de tri. Lesquelles ?
e
e
(c) on parcourt la liste en commenant par la n, en eectuant un change ` chaque fois

c
e
a
que lon trouve deux lments successifs qui ne sont pas dans le bon ordre.
ee
(d) on recherche le minimum de la liste ` trier, on le met en dbut de liste en lchangeant
a
e
e
avec le premier lment et on recommence sur le reste de la liste.
ee
4.5.2
Comprendre
TD 4.21 : Generation de sequences

A laide de la fonction randint(min,max) du module standard random, Dnir les fonctions de
e
gnration suivantes :
e e
1. liste(n) : gn`re une liste de n entiers compris entre 0 et n.
e e
2. nuplet(n) : gn`re un n-uplet de n entiers compris entre 0 et n.
e e
3. chaine(n) : gn`re une cha de n caract`res imprimables.
e e
ne
e
`

TD 4.22 : Application dune fonction a tous les elements dune liste
Dnir une fonction qui applique la mme fonction f ` tous les lments dune liste s.
e
e
a
ee
Exemples : s = [-1,2,3,-4]
, f = abs s = [1,2,3,4]
s = [pi/2,pi,3*pi/2] , f = sin s = [1,0,-1]
TD 4.23 : Que fait cette procedure ?

On consid`re la procdure f ci-dessous.
e
e

183
def f(t,debut,fin):
m = (debut + fin)/2
while m > 0:
for i in range(m,fin+1):
j = i - m
while j >= debut:
print(m,i,j,t)
if t[j] > t[j+m]:
t[j],t[j+m] = t[j+m],t[j]
j = j - m
else: j = debut-1
m = m/2
return
1. Tracer lexcution ` la main de lappel f([4,2,1,2,3,5],0,5).

e
a
2. Que fait cette procdure ?
e
4.5.3
Appliquer
`
TD 4.24 : Codes ASCII et cha
nes de caracteres
1. Ecrire un algorithme qui fournit le tableau des codes ASCII (annexe 4.6.2 page 194) associ
e
a
` une cha (exemple : bon [98, 111, 110]).
ne
2. Ecrire un algorithme qui donne la cha de caract`res associe ` un tableau de codes
ne
e
e a
ASCII (exemple : [98, 111, 110] bon).
TD 4.25 : Operations sur les matrices

1. Dnir une fonction qui teste si une liste m est une matrice.
e
2. Dnir une fonction qui teste si une matrice m est une matrice carre.
e
e
3. Dnir une fonction qui teste si une matrice m est une matrice symtrique.
e
e
4. Dnir une fonction qui teste si une matrice m est une matrice diagonale.
e
5. Dnir une fonction qui multiplie une matrice m par un scalaire x.
e
6. Dnir une fonction qui dtermine la transpose dune matrice m.
e
e
e

184
4.5.4
Analyser
TD 4.26 : Recherche dun motif

Dnir un algorithme qui recherche la premi`re occurence dune squence m au sein dune autre
e
e
e
squence t.
e
TD 4.27 : Recherche de toutes les occurences
Dnir une fonction qui retourne la liste des rangs de toutes les occurences dun lment x dans
e
ee
une liste t.
TD 4.28 : Tri bulles
Dans le tri bulles, on parcourt la liste en commenant par la n, en eectuant un change `
c
e
a
chaque fois que lon trouve deux lments successifs qui ne sont pas dans le bon ordre.
ee
Dnir une fonction qui trie une liste selon la mthode du tri bulles.
e
e
TD 4.29 : Methode delimination de Gauss

Lobjectif est ici de rsoudre dans R un syst`me de n quations linaires ` n inconnues, hoe
e
e
e
a
mog`nes ou non homog`nes, du type A x = b :
e
e
a00 x0
a10 x0
a(n1)0 x0
+
a01 x1
+
a11 x1
+
+ a(n1)1 x1
+
+
+
+
+
a0(n1) x(n1)
+
a1(n1) x(n1)
+
+ a(n1)(n1) x(n1)
=
b0
=
b1
=
= b(n1)
Dnir une fonction solve(a,b) qui retourne le vecteur x solution du syst`me linaire A x = b
e
e
e
selon la mthode dlimination de Gauss dcrite en section 4.6.5 page 199.
e
e
e
4.5.5
Evaluer
TD 4.30 : Comparaison dalgorithmes de recherche.

Comparer les temps dexcution des versions rcursive et itrative des 2 mthodes de recherche
e
e
e
e
dveloppes dans le cours (section 4.3).
e
e
On pourra utiliser la fonction random() ou randint(min,max) du module standard random
pour gnrer des listes de nombres alatoires, et la fonction time() du module standard time
e e
e
pour mesurer le temps avant et apr`s lappel des fonctions.
e

185
TD 4.31 : Comparaison dalgorithmes de tri

Comparer les temps dexcution des direntes versions rcursives et itratives des 3 mthodes
e
e
e
e
e
de tri dveloppes dans le cours (section 4.4).
e
e
On pourra utiliser la fonction random() ou randint(min,max) du module standard random
pour gnrer des listes de nombres alatoires, et la fonction time() du module standard time
e e
e
pour mesurer le temps avant et apr`s lappel des fonctions.
e
4.5.6
TD 4.20 : QCM (4).

Les bonnes rponses sont extraites directement du texte de ce chapitre :
e
1c, 2d, 3d, 4c, 5b, 6d, 7c, 8a, 9c, 10b
TD 4.21 : Gnration de squences.
e e
e
1. Gnration de listes dentiers.
e e
def liste(n):
t = []
for i in range(n):
t.append(randint(0,n))
return t
>>> liste(0)
[]
>>> liste(10)
[6, 7, 9, 8, 5, 4, 9, 1, 8, 9]
2. Gnration de n-uplets dentiers.

e e
def nuplet(n):
t = ()
for i in range(n):
t = t + (randint(0,n),)
return t
>>> nuplet(0)
()
>>> nuplet(10)
(6, 2, 3, 10, 9, 3, 4, 1, 3, 4)
3. Gnration de cha
e e
nes de caract`res.
e
def chaine(n):
t =
for i in range(n):
t = t + chr(randint(32,127)
return t
>>> chaine(0)
>>> chaine(10)
kN K,-Phe

186
TD 4.22 : Application dune fonction ` tous les lments dune liste.

a
ee
def application(f,t):
for i in range(len(t)): t[i] = f(t[i])
return t
s = [pi/2,pi,3*pi/2]
>>> application(sin,s)
[1.0, 1.2246063538223773e-16, -1.0]
La fonction prdnie map(f,t) fait la
e e
mme chose.
e
>>> s = [pi/2,pi,3*pi/2]
>>> map(sin,s)
[1.0, 1.2246063538223773e-16, -1.0]
TD 4.23 : Que fait cette procdure ?

e
>>>
2 2
2 3
2 4
2 4
2 5
1 1
1 2
1 3
1 3
1 4
1 5
f([4,2,1,2,3,5],0,5)
0 [4, 2, 1, 2, 3, 5]
1 [1, 2, 4, 2, 3, 5]
2 [1, 2, 4, 2, 3, 5]
0 [1, 2, 3, 2, 4, 5]
3 [1, 2, 3, 2, 4, 5]
0 [1, 2, 3, 2, 4, 5]
1 [1, 2, 3, 2, 4, 5]
2 [1, 2, 3, 2, 4, 5]
1 [1, 2, 2, 3, 4, 5]
3 [1, 2, 2, 3, 4, 5]
4 [1, 2, 2, 3, 4, 5]
Cette procdure trie une liste selon la mthode du

e
e
tri par incrment dcroissant (tri shell). Au premier
e
e
passage, on consid`re des sous-listes dlments dise
ee
tants de m = (debut+fin)/2 que lon trie sparment.
e e
Au deuxi`me passage, on consid`re des sous-listes
e
e
dlments distants de m/2 que lon trie sparment,
ee
e e
et ainsi de suite. A chaque passage, lincrment m est
e
divis par 2 et toutes les sous-listes sont tries. Le tri
e
e
sarrte quand lincrment est nul.
e
e
TD 4.24 : Codes ASCII et cha

nes de caract`res.
e
1. Cha codes ASCII
ne
def codeASCII(s):
code = []
for i in range(len(s)):
code.append(ord(s[i]))
return code
>>> codeASCII(bon)
[98, 111, 110]
2. Codes ASCII cha

ne
def decodeASCII(code):
s =
s = s + chr(code[i])
return s
>>> decodeASCII([98, 111, 110])

bon

187
TD 4.25 : Oprations sur les matrices.

e
1. Matrice.
def matrice(t):
ok = True
if type(t) is not list or t == []:
ok = False
elif type(t[0]) is not list:
ok = False
else:
i, n, m = 1, len(t), len(t[0])
while i < n and ok == True:
if type(t[i]) is not list:
ok = False
elif len(t[i]) != m:
ok = False
i = i + 1
return ok
>>> matrice(5)
False
>>> matrice([])
False
>>> matrice([5])
False
>>> matrice([[5]])
True
>>> matrice([[5,6],
[7]])
False
>>> matrice([[5,6,7],
[8,9]])
False
>>> matrice([[5,6,7],
[8,9,3]])
True
2. Matrice carre.
e
def matriceCarree(t):
assert matrice(t)
if len(t) > 0 and len(t[0]) == len(t):
ok = True
else: ok = False
return ok
3. Matrice symtrique.
e
>>> matriceCarree([[4,5,6],
[7,8,9]])
False
>>> matriceCarree([[5,6],
[8,9]])
True
>>> matriceCarree([[]])
False

188
def matriceSymetrique(t):
assert matriceCarree(t)
ok,i = True,0
while i < len(t) and ok == True:
j = i + 1
while j < len(t[0]) and ok == True:
if t[i][j] != t[j][i]:
ok = False
else: j = j + 1
i = i + 1
return ok
>>> matriceSymetrique([[5,6],
[8,9]])
False
>>> matriceSymetrique([[5,6],
[6,9]])
True
>>> matriceSymetrique([[5,6,7],
[6,8,9],
[7,9,3]])
True
4. Matrice diagonale.
def matriceDiagonale(t):
assert matriceCarree(t)
ok,i = True,0
while i < len(t) and ok == True:
j = 0
while j < len(t[0]) and ok == True:
if i != j and t[i][j] != 0:
ok = False
else: j = j + 1
i = i + 1
return ok
>>> matriceDiagonale([[5,6],
[8,9]])
False
>>> matriceDiagonale([[5,0],
[0,9]])
True
>>> matriceDiagonale([[5,0,0],
[0,0,0],
[0,0,3]])
True
5. Multiplication dune matrice par un scalaire.

def multiplicationScalaire(t,x):
assert matrice(m)
assert type(x) is int or type(x) is float
for i in range(len(t)):
for j in range(len(t[0])):
t[i][j] = x*t[i][j]
return
6. Transpose dune matrice.

e
>>> multiplicationScalaire([[5,6],
[2,7]],3)
[[15, 18], [6, 21]]

def transposee(t):
assert matrice(t)
s = []
for j in range(len(t[0])):
s.append([])
s[j].append(t[i][j])
return s
189
>>> transposee([[1,2],[4,5]])
[[1, 4], [2, 5]]
>>> transposee([[1,2,3],[4,5,6]])
[[1, 4], [2, 5], [3, 6]]
TD 4.26 : Recherche dun motif.

def motif(t,m,debut,fin):
assert type(m) is list
i,ok = debut,False
while i + len(m) - 1 <= fin and not ok:
if t[i:i+len(m)] == m and m != []:
ok = True
else: i = i + 1
return ok,i
>>> motif([1,2,3,2,3,4],[2,4],0,5)
(False, 5)
>>> motif([1,2,3,2,3,4],[2,3],0,5)
(True, 1)
>>> motif([1,2,3,2,3,4],[2,3],2,5)
(True, 3)
>>> motif([1,2,3,2,3,4],[2,3,4],0,5)
(True, 3)
TD 4.27 : Recherche de toutes les occurences.

def rechercheTout(t,x):
occurs = []
if t[i] == x: occurs.append(i)
return occurs
>>>
[0,
>>>
[1]
>>>
[]
rechercheTout([1,2,1,5,1],1)
2, 4]
>>>
>>>
[4,
>>>
>>>
[9,
s = [9,8,7,6,5,4]
triBulles(s,0,len(s)-1)
5, 6, 7, 8, 9]
s = [9,8,7,6,5,4]
triBulles(s,1,4)
5, 6, 7, 8, 4]
TD 4.28 : Tri bulles.

def triBulles(t,debut,fin):
while debut < fin:
for j in range(fin,debut,-1):
if t[j] < t[j-1]:
t[j],t[j-1] = t[j-1],t[j]
debut = debut + 1
return t

190
TD 4.29 : Mthode dlimination de Gauss.
e
e
def solve(a,b):
assert matriceCarree(a)
assert type(b) is list
assert len(a) == len(b)
if triangularisation(a,b) == True:
x = backsubstitutions(a,b)
else: x = []
return x
>>> a, b = [[4]], [1]
>>> solve(a,b)
[0.25]
>>> a, b = [[1,1],[1,-1]], [1,0]
>>> solve(a,b)
[0.5, 0.5]
>>> a = [[2,-1,2],[1,10,-3],[-1,2,1]]
>>> b = [2,5,-3]
>>> solve(a,b)
[2.0, 0.0, -1.0]
>>> a = [[ 1, 0, 0, -1, 1, 0],

[ 1, 1, 0, 0, 0,-1],
[ 0, 1,-1, 0, -1, 0],
[10,-10, 0, 0,-10, 0],
[ 0, 0, 5,-20,-10, 0],
[ 0, 10, 5, 0, 0,10]]
>>> b = [0,0,0,0, 0,12]
>>> solve(a,b)
[0.25945945945945936,
0.35675675675675667,
0.45405405405405402,
0.16216216216216217,
-0.097297297297297303,
0.61621621621621636]
>>> a, b = [[10,7,8,7],[7,5,6,5],[8,6,10,9],[7,5,9,10]], [32,23,33,31]

>>> solve(a,b)
[1.0000000000000102, 0.99999999999998335, 1.000000000000004, 0.99999999999999778]
>>> a = [[10,7,8.1,7.2],[7.08,5.04,6,5],[8,5.98,9.89,9],[6.99,4.99,9,9.98]]
>>> solve(a,b)
[28714.563366527444, -47681.976061485781, 12326.759748689999, -7387.0215554531824]
>>> a = [[10,7,8,7],[7,5,6,5],[8,6,10,9],[7,5,9,10]], [32.01,22.99,33.01,30.99]
>>> solve(a,b)
[1.8199999999999306, -0.35999999999988425, 1.3499999999999692, 0.79000000000001847]

191
def pivot(a,i0):
maxi = fabs(a[i0][i0])
r = i0
for i in range(i0+1,len(a)):
if fabs(a[i][i0]) > maxi:
maxi = fabs(a[i][i0])
r = i
return r
def substractRows(a,b,k,i):
q = 1.*a[k][i]/a[i][i]
a[k][i] = 0
b[k] = b[k] - q*b[i]
for j in range(i+1,len(a)):
a[k][j] = a[k][j] - q*a[i][j]
return
def triangularisation(a,b):
ok = True; i = 0
while i < len(a) and ok == True:
p = pivot(a,i)
if i != p:
a[i],a[p] = a[p],a[i]
b[i],b[p] = b[p],b[i]
if a[i][i] == 0: ok = False
else:
for k in range(i+1,len(a)):
substractRows(a,b,k,i)
i = i + 1
return ok
def backsubstitutions(a,b):
n = len(a); x = []
for k in range(n): x.append(0)
x[n-1] = 1.*b[n-1]/a[n-1][n-1]
for i in range(n-2,-1,-1):
x[i] = b[i]
for j in range(i+1,n):
x[i] = x[i] - a[i][j]*x[j]
x[i] = 1.*x[i]/a[i][i]
return x
TD 4.30 : Comparaison dalgorithmes de recherche.

def mesureRecherche(f,t,x):
t0 = time()
f(tmp,x,0,len(t)-1)
dt = time() - t0
return dt
>>> s = liste(1000)
>>> x = s[len(s)-1]
>>> mesureRecherche(rechercheSequentielle,s,x)
0.00062489509582519531
>>> s = liste(100000)
>>> x = s[len(s)-1]
>>> mesureRecherche(rechercheSequentielle,s,x)
0.046545028686523438

192
TD 4.31 : Comparaison dalgorithmes de tri.
def mesureTri(f,t):
tmp = [x for x in t]
t0 = time()
f(tmp,0,len(t)-1)
dt = time() - t0
return dt
>>> s = liste(10000)
>>> mesureTri(triSelection,s)
23.040315866470337
>>> mesureTri(triInsertion,s)
22.086866855621338
>>> mesureTri(triRapide,s)
0.24324798583984375
4.6. ANNEXES
4.6
4.6.1
193
Annexes
Type abstrait de donnes
e
Nous nous intressons ici ` une description plus formelle du type abstrait de donnes Sequence
e
a
e
selon un formalisme logique inspir de [13]. On notera B lensemble des boolens ({0, 1}), E
e
e
lensemble des lments, S lensemble des squences, F lensemble des fonctions E E et P
ee
e
lensemble des fonctions E B. Le vocabulaire initial de la thorie des squences comprend
e
e
alors :
une constante [] qui reprsente la squence vide (on notera S = S {[]}) ;
e
e
un oprateur x s qui traduit linsertion dun lment x E en tte de la squence s S.
e
ee
e
e
Dans ce cadre, la dnition axiomatique des squences repose sur les 2 axiomes suivants :
e
e
1. [] est une squence : [] S,
e
2. x s est une squence : x E, s S, x s S.
e
Pour chaque opration considre, nous indiquerons sa signature, sa dnition axiomatique
e
ee
e
(souvent rcursive) et son quivalent Python.
e
e
head(s) : tte (premier lment) dune squence
e
ee
e
head : S E
, x = head(x s)
s[0]
tail(s) : queue dune squence (la squence sans son premier lment)
e
e
ee
tail : S E
, s = tail(x s)
s[1:len(s)]
x in s : appartenance dun lment ` une squence
ee
a
e
x = head(s)
in
: ESB ,
x in s
x in tail(s)
len(s) : longueur dune squence (nombre dlments)
e
ee
len([]) = 0
len
:SN
,
len(x s) = len(s) + 1
len(s)
concat(s1 , s2 ) (ou s1 + s2 ) : concatnation de deux squences
e
e
[] + s = s
concat: S S S ,
s1 + s2
s3 = (x s1 ) + s2 = x (s1 + s2 )
eme lment de la squence
`
ith(s, i) (ou si ) : i
ee
e
(x s)0 = x
ith
: S N E ,
(x s)i = si1 0 < i len(s)
s[i]

194
Fig. 4.19 : Codes des caracteres de controle

code
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
caract`re
e
NUL
SOH
STX
ETX
EOT
ENQ
ACK
BEL
BS
TAB
LF
VT
FF
CR
SO
SI
DLE
DC1
DC2
DC3
DC4
NAK
SYN
ETB
CAN
EM
SUB
ESC
FS
GS
RS
US
signication
Null
Start of heading
Start of text
End of text
End of transmission
Enquiry
Acknowledge
Bell
Backspace
Horizontal tabulation
Line Feed
Vertical tabulation
Form feed
Carriage return
Shift out
Shift in
Data link escape
Device control 1
Device control 2
Device control 3
Device control 4
Negative acknowledgement
Synchronous idle
End of transmission block
Cancel
End of medium
Substitute
Escape
File separator
Group separator
Record separator
Unit separator
foreach(f, s) : application dune fonction ` tous les lments dune squence

a
ee
e
foreach(f, []) = []
foreach: F S S ,
foreach(f, x s) = f (x) foreach(f, s) [f(x) for x in s]
collect(p, s) : slection sous condition des lments dune squence
e
ee
e
collect(p, []) = []
collect : P S S , collect(p, x s) = x collect(p, s) si p(x)
[x for x in s if p(x)]
collect(p, x s) = collect(p, s) si p(x)
4.6.2
Codes ASCII
Lordinateur stocke toutes les donnes sous forme numrique (ensemble de bits). En partie
e
culier, les caract`res ont un quivalent numrique : le code ASCII (American Standard Code for
e
e
e
Information Interchange). Le code ASCII de base code les caract`res sur 7 bits (128 caract`res,
e
e
de 0 ` 127).
a
Les codes 0 ` 31 sont des caract`res de contrle (gure 4.19).
a
e
o
Les codes 32 ` 47, de 58 ` 64, de 91 ` 96 et de 123 ` 126 sont des symboles de ponctuation.
a
a
a
a
32
58
:
59
;
33
!
60
<
34
"
61
=
35
#
62
>
36
$
63
?
37
%
64
@
38
&
39
40
(
41
)
42
*
43
+
91
[
92
\
93
]
94
^
95
96
44
,
123
{
45
-
46
.
124
|
47
/
125
}
126
~
Les codes de 48 ` 57 reprsentent les 10 chires de 0 ` 9.

a
e
a
Les codes 65 ` 90 reprsentent les majuscules de A ` Z,
a
e
a
Les codes 97 ` 122 reprsentent les minuscules de a ` z (il sut dajouter 32 au code
a
e
a
ASCII dune majuscule pour obtenir la minuscule correspondante).
Les caract`res accentus (, ` . . .) font lobjet dun code ASCII tendu de 128 ` 255.
e
e e e
e
a
4.6.3
Les squences en Python

e
Les principales oprations sur les squences en Python (list, tuple, str) sont listes dans
e
e
e
les tableaux ci-dessous, extraits du Python 2.5 Quick Reference Guide [10].
4.6. ANNEXES
Operation on sequences
(list, tuple, str)
x in s
x not in s
s1 + s2
s * n, n*s
s[i]
s[i :j[ :step]]
len(s)
min(s)
max(s)
Operation on list
s[i] = x
s[i :j [ :step]] = t
del s[i :j[ :step]]
s.count(x)
s.index(x[,start[,stop]])
s.append(x)
s.extend(x)
s.insert(i, x)
s.remove(x)
s.pop([i])
s.reverse()
s.sort([cmp ])
195
Result
True if an item of s is equal to x, else False
False if an item of s is equal to x, else True
the concatenation of s1 and s2
n copies of s concatenated
ith item of s, origin 0
Slice of s from i (included) to j(excluded). Optional step
value, possibly negative (default : 1)
Length of s
Smallest item of s
Largest item of s
Result
item i of s is replaced by x
slice of s from i to j is replaced by t
same as s[i :j] = []
returns number of is for which s[i] == x
returns smallest i such that s[i] == x. start and stop
limit search to only part of the list
same as s[len(s) : len(s)] = [x]
same as s[len(s) :len(s)]= x
same as s[i :i] = [x] if i>= 0. i == -1 inserts before
the last element
same as del s[s.index(x)]
same as x = s[i] ; del s[i] ; return x
reverses the items of s in place
sorts the items of s in place
196
Operation on str
s.capitalize()
s.center(width[,
fillChar= ])
s.count(sub[,start[,
end]])
s.decode([encoding[,
errors]])
s.encode([encoding[,
errors]])
s.endswith(suffix[,
start[,end]])
s.expandtabs([tabsize])
s.find(sub[,start[,
end]])
s.index(sub[,start[,
end]])
s.isalnum()
s.isalpha()
s.isdigit()
s.isspace()
Result
Returns a copy of s with its rst character capitalized, and
the rest of the characters lowercased
Returns a copy of s centered in a string of length width,
surrounded by the appropriate number of fillChar characters
Returns the number of occurrences of substring sub in string
s
Returns a unicode string representing the decoded version of
str s, using the given codec (encoding). Useful when reading
from a le or a I/O function that handles only str. Inverse
of encode
Returns a str representing an encoded version of s. Mostly
used to encode a unicode string to a str in order to print it
or write it to a le (since these I/O functions only accept
str). Inverse of decode
Returns True if s ends with the specied suffix, otherwise
return False.
Returns a copy of s where all tab characters are expanded
using spaces
Returns the lowest index in s where substring sub is found.
Returns -1 if sub is not found
like find(), but raises ValueError when the substring sub
is not found
Returns True if all characters in s are alphanumeric, False
otherwise
Returns True if all characters in s are alphabetic, False
otherwise
Returns True if all characters in s are digit characters, False
otherwise
Returns True if all characters in s are whitespace characters,
False otherwise
4.6. ANNEXES
s.istitle()
s.islower()
s.isupper()
separator.join(seq)
s.ljust/rjust/center(
width[,fillChar= ])
s.lower()
s.lstrip([chars])
s.partition(separ)
s.replace(old,new[,
maxCount=-1])
s.rfind(sub[ ,start[,
end]])
s.rindex(sub[,start[,
end]])
s.rpartition(separ)
s.rstrip([chars])
197
Returns True if string s is a titlecased string, False otherwise

Returns True if all characters in s are lowercase,False otherwise
Returns True if all characters in s are uppercase, False
otherwise
Returns a concatenation of the strings in the sequence seq, separated by string separator, e.g. :
",".join([A,B,C]) -> "A,B,C"
Returns s left/right justied/centered in a string of
length width
Returns a copy of s converted to lowercase
Returns a copy of s with leading chars (default : blank
chars) removed
Searches for the separator separ in s, and returns a tuple
(head, sep, tail) containing the part before it, the separator itself, and the part after it. If the separator is not
found, returns s and two empty strings
Returns a copy of s with the rst maxCount (-1 : unlimited)
occurrences of substring old replaced by new
Returns the highest index in s where substring sub is found.
Returns -1 if sub is not found
like rfind(), but raises ValueError when the substring sub
is not found
Searches for the separator separ in s, starting at the end of
s, and returns a tuple (tail, sep, head) containing the
part before it, the separator itself, and the part after it. If
the separator is not found, returns two empty strings and s
Returns a copy of s with trailing chars (default : blank
chars) removed, e.g. aPath.rstrip(/) will remove the
trailing / from aPath if it exists

198
s.split([separator[,
maxsplit]])
s.rsplit([separator[,
maxsplit]])
s.splitlines([keepends])
s.startswith(prefix[,
start[,end]])
s.strip([chars])
s.swapcase()
s.title()
s.translate(table[,
deletechars])
s.upper()
s.zfill(width)
4.6.4
Returns a list of the words in s, using separator as the

delimiter string
Same as split, but splits from the end of the string
Returns a list of the lines in s, breaking at line boundaries
Returns True if s starts with the specied prefix, otherwise
returns False. Negative numbers may be used for start and
end
Returns a copy of s with leading and trailing chars (default :
blank chars) removed
Returns a copy of s with uppercase characters converted to
lowercase and vice versa
Returns a titlecased copy of s, i.e. words start with uppercase characters, all remaining cased characters are lowercase
Returns a copy of s mapped through translation table table
Returns a copy of s converted to uppercase
Returns the numeric string left lled with zeros in a string
of length width
Les chiers en Python
Les principales oprations sur les chiers en Python (type file) sont listes dans le tableau
e
e
ci-dessous, extrait du Python 2.5 Quick Reference Guide [10].
open(filename[,mode=r,[bufsize]]) returns a new le object. filename is the le
name to be opened. mode indicates how the le is to be opened (r, w, a, +, b,
U). bufsize is 0 for unbuered, 1 for line buered, negative or omitted for system default, >1
for a buer of (about) the given size.
4.6. ANNEXES
Operation on file
f.close()
f.fileno()
f.flush()
f.isatty()
f.next()
f.read([size])
f.readline()
f.readlines()
for line in f : ...
f.seek(offset[,
whence=0])
f.tell()
f.truncate([size])
f.write(str)
f.writelines(list)
4.6.5
199
Result
Close le f
Get leno (fd) for le f
Flush le fs internal buer
True if le f is connected to a tty-like dev, else False
Returns the next input line of le f, or raises StopIteration
when EOF is hit
Read at most size bytes from le f and return as a string
object. If size omitted, read to EOF
Read one entire line from le f. The returned line has a
trailing n, except possibly at EOF. Return on EOF
Read until EOF with readline() and return a list of lines
read
Iterate over the lines of a le f (using readline)
Set le fs position
whence == 0 then use absolute indexing
whence == 1 then offset relative to current pos
whence == 2 then offset relative to le end
Return le fs current position (byte oset)
Truncate fs size. If size is present, f is truncated to (at
most) that size, otherwise f is truncated at current position
(which remains unchanged)
Write string str to le f
Write list of strings to le f. No EOL are added
Mthode dlimination de Gauss

e
e
Lobjectif est ici de rsoudre dans R un syst`me de n quations linaires ` n inconnues,

e
e
e
e
a
homog`nes ou non homog`nes, du type A x = b :
e
e

200
a00 x0
a10 x0
a(n1)0 x0
Fig. 4.20 : Pont de Wheatstone
i1
r1
i4
r4
r5 i5
i2
B
i3
r2
r3
D
E,r6
=
=
=
=
=
=
=
10
10
5
20
10
10
12V
+
+
+
+
+
a0(n1) x(n1)
+
a1(n1) x(n1)
+
+ a(n1)(n1) x(n1)
=
b0
=
b1
=
= b(n1)
(4.1)
De nombreux exemples traits dans les enseignements scientiques conduisent ` la ncessit de

e
a
e
e
rsoudre un syst`me de n quations linaires ` n inconnues, homog`nes ou non homog`nes, du
e
e
e
e
a
e
e
type Ax = b. La gure 4.20 propose ` titre dexemple le cas du pont de Wheatstone en lectricit.
a
e
e
Les ponts ont t utiliss pour la mesure des rsistances, inductances et capacits jusqu` ce que
ee
e
e
e
a
les progr`s en lectronique les rendent obsol`tes en mtrologie. Toutefois la structure en pont
e
e
e
e
reste encore utilise dans de nombreux montages (voir par exemple [14]).
e
La premi`re mthode gnralement utilise pour trouver la solution dun syst`me dquae
e
e e
e
e
e
tions linaires tel que le syst`me (4.1) est celle qui consiste ` liminer les inconnues (xi ) en
e
e
a e
combinant les quations [8]. Pour illustrer cette mthode, nous commencerons par tudier un
e
e
e
exemple simple pouvant seectuer ` la main, puis nous passerons au cas gnral pour prsenter
a
e e
e
la mthode dlimination de Gauss.
e
e
Etude dun cas particulier
i6
r1
r2
r3
r4
r5
r6
E
+
a01 x1
+
a11 x1
+
+ a(n1)1 x1
i4 = i1 + i5
i6 = i1 + i2
i2 = i3 + i5
10i1 = 10i2 + 10i5
10i5 = 5i3 20i4
12 10i6 = 10i2 + 5i3
Considrons le syst`me suivant :

e
e
x2 = 1
x0 + x1 +
2x0 + 4x1 + 8x2 = 10
3x0 + 9x1 + 27x2 = 33

Pour rsoudre un tel syst`me, lide de base est de triangulariser le syst`me de telle mani`re
e
e
e
e
e
quil soit possible de remonter les solutions par substitutions successives.
`
`
La premi`re tape consiste ` liminer le terme en x0 des 2eme et 3eme quations. Cherchons
e e
ae
e
eme quation. Pour cela nous multiplions la 1ere
`
`
tout dabord ` liminer le terme en x0 de la 2
ae
e
`
quation par le coecient de x0 de la 2eme quation (a10 = 2). On obtient le nouveau syst`me :
e
e
e
2x0 + 2x1 + 2x2 = 2

2x0 + 4x1 + 8x2 = 10
3x0 + 9x1 + 27x2 = 33
4.6. ANNEXES
201
On soustrait alors la premi`re quation de la deuxi`me quation, ce qui conduit au syst`me :

e e
e
e
e
2x0 + 2x1 + 2x2 = 2

2x1 + 6x2 = 8
3x0 + 9x1 + 27x2 = 33

`
On recommence lopration pour liminer le terme en x0 de la 3eme quation. Pour cela, on
e
e
e
ram`ne ` 1 le coecient de x0 dans la premi`re quation en divisant cette quation par 2
e a
e e
e
`
`
(a00 = 2), puis nous multiplions la 1ere quation par le coecient de x0 de la 3eme quation
e
e
(a20 = 3).
3x0 + 3x1 + 3x2 = 3

2x1 + 6x2 = 8
3x0 + 9x1 + 27x2 = 33

` e
`
On soustrait ensuite la 1ere quation de la 3eme quation :
e
3x0 + 3x1 + 3x2 = 3

2x1 + 6x2 = 8
6x1 + 24x2 = 30
On obtient un nouveau syst`me linaire dans lequel seule la premi`re quation contient un terme
e
e
e e
`
en x0 . Lquation utilise (ici la 1ere quation) pour liminer une inconnue dans les quations
e
e
e
e
e
eme et 3eme quations) est appele lquation-pivot. Dans lquation-pivot
`
`
qui suivent (ici les 2
e
e e
e
choisie, le coecient de linconnue qui est limine dans les autres quations est appel le pivot
e
e
e
e
de lquation (ici a00 ).
e
La deuxi`me tape consiste ` liminer le terme en x1 de la troisi`me quation en utilisant
e
e
ae
e
e
`
la deuxi`me quation comme quation-pivot. On ram`ne ` 1 le coecient de x1 dans la 2eme
e
e
e
e a
quation en divisant lquation par 2 (a11 = 2), puis on la multiplie par 6 (a21 = 6) pour que les
e
e
`
`
`
2eme et 3eme quations aient le mme terme en x1 . Tout revient ` multiplier la 2eme quation
e
e
a
e
par 3 (a21 /a11 = 6/2 = 3) :
3x0 + 3x1 + 3x2 = 3

6x1 + 18x2 = 24
6x1 + 24x2 = 30

202
`
`
`
Il reste ` soustraire la 2eme quation de la 3eme pour liminer le terme en x1 de la 3eme quation :
a
e
e
e
3x0 + 3x1 + 3x2 = 3

6x1 + 18x2 = 24
6x2 = 6
On obtient ainsi un syst`me triangulaire dquations linaires dont on peut calculer directement
e
e
e
eme quation : 6x = 6 x = 1. On porte cette valeur de x dans
`
la valeur de x2 par la 3
e
2
2
2
la deuxi`me quation, ce qui nous permet de calculer x1 : 6x1 + 18 1 = 24 x1 = 1. En
e
e
reportant les valeurs de x2 et x1 dans la premi`re quation, on en dduit la valeur de x0 :
e e
e
3x0 + 3 1 + 3 1 = 3 x0 = 1. On vrie simplement que les valeurs obtenues sont solutions
e
du syst`me initial :
e
1
1
1 1 1
x2 = 1
x0 + x1 +
2 4 8 1 = 10
2x0 + 4x1 + 8x2 = 10
33
1
3 9 27
3x0 + 9x1 + 27x2 = 33
Etude du cas gnral
e e
De mani`re gnrale, la mthode prcdente consiste ` rduire le syst`me de n quations
e
e e
e
e e
a e
e
e
a
` n inconnues ` un syst`me triangulaire quivalent qui peut tre ensuite rsolu facilement par
a
e
e
e
e
substitutions. En quelque sorte le syst`me (4.1) doit tre transform en un syst`me quivalent
e
e
e
e
e
du type :
a0(n1) x(n1) =
b0
a00 x0 + a01 x1 + a02 x2 + +
(1)
(1)
(1)
(1)
a11 x1 + a12 x2 + +
a1(n1) x(n1) = b1
(2)
+ a22 x2 + +
+
(2)
(2)
a2(n1) x(n1) = b2
=
(n2)
(n2)
a(n1)(n1) x(n1) = b(n1)
(4.2)
o` lindice suprieur dsigne le nombre dtapes ` la suite desquelles est obtenu le coecient
u
e
e
e
a
considr.
ee
Lquation de rang 0 du syst`me (4.1) est dabord divise par le coecient a00 de x0 (suppos
e
e
e
e
non nul). On obtient :
x0 +
a0(n1)
a01
a02
b0
x1 +
x2 + +
x(n1) =
a00
a00
a00
a00
(4.3)
4.6. ANNEXES
203
Cette quation (4.3) est alors multipli par a10 , coecient de x0 dans la deuxi`me quation du
e
e
e
e
syst`me (4.1). Le rsultat est ensuite soustrait de la deuxi`me quation du syst`me (4.1), ce
e
e
e
e
e
qui limine x0 dans la deuxi`me quation. Dune mani`re gnrale on multiplie la relation (4.3)
e
e
e
e
e e
e
par ai0 , coecient de x0 dans lquation de rang i du syst`me (4.1) et on retranche le rsultat
e
e
`
obtenu de cette mme ieme quation. A la n x0 est limin de toutes les quations, except de
e
e
e
e
e
e
la premi`re, et on obtient le syst`me ainsi transform :
e
e
e
a00 x0 +
a01 x1 +
(1)
a11 x1 +
(1)
a21 x1 +
(1)
a02 x2 + +
(1)
a12 x2 + +
(1)
a22 x2 + +
(1)
a0(n1) x(n1) =
(1)
a1(n1) x(n1) =
(1)
a2(n1) x(n1) =
(1)
b0
(1)
b1
(1)
b2
(1)
b3
(4.4)
a31 x1 +
a32 x2 + +
a3(n1) x(n1) =
+
+ +
=
(1)
(1)
(1)
(1)
a(n1)1 x1 + a(n1)2 x2 + + a(n1)(n1) x(n1) = b(n1)
(1)
Lquation de rang 1 dans le nouveau syst`me (4.4) devient alors lquation-pivot et a11 le pivot
e
e
e
de lquation. De la mme faon on limine x1 des quations du rang 2 au rang n 1 dans le
e
e
c
e
e
syst`me (4.4), et on obtient :
e
a00 x0 + a01 x1 +
(1)
a11 x1 +
a02 x2 + +
(1)
a12 x2 + +
(2)
a22 x2 + +
(2)
a0(n1) x(n1) =
(1)
a1(n1) x(n1) =
(2)
a2(n1) x(n1) =
(2)
b0
(1)
b1
(2)
b2
(2)
b3
a32 x2 + +
a3(n1) x(n1) =
+ +
=
(2)
(2)
(2)
a(n1)2 x2 + + a(n1)(n1) x(n1) = b(n1)
(4.5)
Lquation de rang 2 dans le nouveau syst`me (4.5) fait oce ` son tour dquation pivot, et ainsi
e
e
a
e
de suite jusqu` obtenir le syst`me triangulaire (4.2). Une fois obtenu ce syst`me triangulaire,
a
e
e
on calcule directement la valeur de x(n1) par la derni`re relation du syst`me triangulaire.
e
e
En portant cette valeur dans la relation prcdente, on calculera x(n2) , et ainsi de suite en
e e
remontant le syst`me triangulaire (4.2). A chaque tape k, on a donc les relations suivantes :
e
e

204
1. Triangularisation
(k1)
(k)
a
(k1)
a
ij = a(k1) ip
apj
ij
(k1)
app
(k1)
aip
(k)
(k1)
b
i
= bi
(k1) b(k1)
p
app
2. Remonte par substitutions
e
x
(n1) =
xi
Remarque 4.15 : Cette mthode est connue sous le
e
nom de mthode dlimination de Gauss (galement
e
e
e
connue sous le nom de mthode de triangularisation
e
de Gauss ou mthode du pivot de Gauss). Elle fut
e
nomme ainsi en lhonneur du mathmaticien allemand
e
e
Johann Carl Friedrich Gauss (17771855), mais elle
est connue des Chinois depuis au moins le 1er si`cle de
e
notre `re. Elle est rfrence dans le livre chinois Jiuze
ee
e
hang suanshu o` elle est attribue ` Chang Tsang
u
e a
`
chancelier de lempereur de Chine au 2eme si`cle avant
e
notre `re [4].
e
p < i (n 1)
p j (n 1)
b(n1)
a(n1)(n1)
n1
bi
=
avec
e
k : tape
p : rang du pivot
avec 0 i < (n 1)
aij xj
j=i+1
aii
Jusqu` prsent, on a admis que le pivot au cours du processus de triangularisation tait non
a e
e
nul (app = 0). Si ce nest pas le cas, on doit permuter lquation-pivot avec une autre ligne dans
e
laquelle le pivot est dirent de 0. Il se peut galement que le pivot, sans tre nul, soit tr`s petit
e
e
e
e
et lon a intrt l`-aussi ` interchanger les lignes comme pour le cas dun pivot nul. En fait, pour
ee a
a
augmenter la prcision de la solution obtenue, on a toujours intrt ` utiliser la ligne qui a le
e
ee a
plus grand pivot.
Jeu de tests
Lalgorithme de rsolution de tels syst`mes linaires pourra tre test ` laide des syst`mes
e
e
e
e
ea
e
suivants :
Test
Syst`me A x = b
e
Solution
A
b
exacte
4
1
1/4
1
1
1
1
1/2
2
1 1
0
1/2
2 1
2
2
2
1 10 3 5 0
3
1
2
1
3
1
4.6. ANNEXES
205
Test
Syst`me A x = b
e
Solution
A
b
exacte

10 7 8 7
32
1
7 5 6 5
23
1

8 6 10 9
33
1
7 5 9 10
31
1
10
7 8.1 7.2
32
23
7.08 5.04
6
5
33
8 5.98 9.89
9
6.99 4.99
9 9.98
31
10 7 8 7
32.01
7 5 6 5
22.99
8 6 10 9
33.01
7 5 9 10
30.99
Test
1
0
1 2
0
1
0
1
1 /2
0 /2
1
1
0
1
1
0
1
10 10
0
0
0
10
0
0
2
4
8 3
0
0
4 12 2
2 /4
3 /8
3 2 /4
2
3
2
3 2
Syst`me A x = b
e
A
1
0
0
0
0 1
1
0 1
0
0
0 10
0
5 20 10
0
5
0
0 10

0
0
0
0
16 4
32 5
64 6 128 7

0
0
0
0

32 3
80 4 192 5 448 6

4 /16 5 /32 6 /64 7 /128

3 /2 5 4 /16 3 5 /16 7 6 /64

4
5
6
7
4 3
5 4
6 5
7 6
b
0
0
0
0
0
12
4
4
0
0
2
2
1
0
Remarque 4.16 : Les tests 5 et 6 sont des variations

du test 4 : A5 = A4 +A et b6 = b4 +b. Ces 2 tests sont
eectus pour valuer les consquences sur la solution x
e
e
e
dune perturbation A de A4 et dune perturbation b
de b4 .
0
1
0
0
0.1
0.2
B 0.08
0.04
0
0 C
C
A = B
@
0 0.02 0.11
0 A
0.01 0.01
0 0.02
1
0
0.01
B 0.01 C
C
b = B
@ 0.01 A
0.01
Le test 7 correspond ` lexemple du pont de Wheatstone
a
(gure 4.20). Le test 8 correspond ` la dtermination de
a
e
la forme dune came rotative qui doit mettre en mouvement un axe suivant une loi horaire donne (exemple tir
e
e
de [8]).
206
Annexe A
Grands classiques
Algorithmes
Cette annexe recense quelques algorithmes historiques dont les principales vertus aujourdhui sont dordre pdagogique. A ce titre, tout informaticien dbutant doit tre capable de les
e
e
e
rednir lui-mme. Pour simplier la lecture de ces algorithmes, ils sont prsents sous forme de
e
e
e
e
fonctions Python pour lesquelles les descriptions, les prconditions et les tests unitaires sont
e
volontairement omis.
Spcication :
e
fibonacci
n:int
u:int
[n >= 0]
u = fibonacci(n) est le nombre de Fibonacci

a
` lordre n si n :int >= 0.
Exemples : fibonacci(0) 1
fibonacci(2) 2
fibonacci(9) 55
Implmentation :
e
fibonacci
u = 1
u1 = 1
u2 = 1
i = 2
n:int
[n >= 0]
[i in 2..n]
u1:int
u2:int
i:int
[else]
207
u = u1 + u2
u2 = u1
u1 = u
i = i + 1
u:int
A.1 Algorithme dEuclide . .

A.2 Coecients du binme .
o
A.3 Conversion en base b . .
A.4 Courbe fractale de Koch
A.5 Crible dEratost`ne . . .
e
A.6 Dveloppement limit .
e
e
A.7 Fonction factorielle . . .
A.8 Fonction puissance . . .
A.9 Nombres de Fibonacci .
A.10 Palindrome . . . . . . . .
A.11 Produit de matrices . . .
A.12 Recherche dichotomique
A.13 Recherche squentielle .
e
A.14 Tours de Hano . . . . . .
A.15 Tri bulles . . . . . . . . .

A.16 Tri fusion . . . . . . . . .
A.17 Tri par insertion . . . . .
A.18 Tri par slection . . . . .
e
A.19 Tri rapide . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
208
209
210
211
212
213
214
214
215
216
216
217
217
218
219
219
220
221
221
208
ANNEXE A. GRANDS CLASSIQUES
Algorithme dEuclide
Remarque A.1 : Voir aussi les exemples 2.3 page 45,
2.9 page 51, 2.13 page 55, la gure 2.16 page 56 et le TD
2.15 page 56.
Lalgorithme dEuclide concerne le calcul du plus grand commun diviseur (pgcd) de 2 entiers.
Le pgcd de 2 entiers a et b peut se calculer en appliquant la relation de rcurrence pgcd(a, b) =
e
pgcd(b, a%b) jusqu` ce que le reste (a%b) soit nul. Cette rcurrence se traduit par lalgorithme
a
e
rcursif suivant :
e
def pgcd(a,b):
if b == 0: d = a
else: d = pgcd(b,a%b)
return d
>>> pgcd(0,9)
9
>>> pgcd(12,18)
6
Lalgorithme ci-dessous est la version itrative de cet algorithme rcursif.

e
e
Algorithme A.1 Algorithme dEuclide
1
2
3
4
5
6
def pgcd (a , b ):
while b != 0:
r = a % b
a = b
b = r
return a
Coecients du binme
o
Remarque A.2 :
3.18 page 131.
Voir aussi les TD 2.34 page 71 et
Il sagit ici de dvelopper le binme (a + b)n et de dterminer les coecients des termes
e
o
e
ank bk .
n
Remarque A.3 : Le coecient binomial
(ou
k
k
Cn , combinaison de k parmi n) se lit k parmi n .
(a + b) =
k=0
n
k
n
nk k
b =
k=0
n!
ank bk
k!(n k)!
La formule de Pascal lie les coecients binomiaux entre eux selon la relation de rcurrence :
e
n
k
n1
k
n1
k1
pour (0 < k < n) et
n
0
n
n
=1
Elle permet un calcul rapide des coecients pour les petites valeurs de n sans division ni multiplication. Elle est utilise pour construire ` la main le triangle de Pascal (remarque A.4) et cest
e
a
encore elle que est implmente dans la version rcursive du calcul des coecients du binme.
e
e
e
o
209
def coefBinome(n,k):
if k == 0 or n == 0 or n == k:
c = 1
else:
c = coefBinome(n-1,k) + coefBinome(n-1,k-1)
return c
>>> coefBinome(2,1)
1
>>> coefBinome(7,4)
35
>>> coefBinome(14,7)
3432
La version itrative ci-dessous calcule directement le numrateur num et le dnominateur den du

e
e
e
coecient c en tenant compte de la simplication suivante :
n
k
n (n 1) (n k + 2) (n k + 1)
n!
=
k!(n k)!
1 2 3k
Algorithme A.2 Coecients du binme

o
1
2
3
4
5
6
7
def coefBinome (n , k ):
num , den = 1 , 1
for i in range (1 , k +1):
num = num *( n - i +1)
den = den * i
c = num / den
return c
Remarque A.4 : Triangle de Pascal

k
n Cn (0 k n)
0 1
1 1 1
2 1 2 1
3 1 3 3 1
4 1 4 6 4
1
5 1 5 10 10
5
1
6 1
6 1 6 15 20 15
7 1 7 21 35 35 21 7 1
8 1 8 28 56 70 56 28 8 1
9 1 9 36 84 126 126 84 36 9 1
.
.
.
.
.
.
Conversion en base b
Un entier n en base b est reprsent par une suite de chires (rm rm1 . . . r1 r0 )b o` les ri
e
e
u
i=m
ri bi .
sont des chires de la base b (0 ri < b). Ce nombre n a pour valeur

i=0
i=m
n = rm bm + rm1 bm1 + . . . + r1 b1 + r0 b0 =
ri bi
i=0
Nous choisirons ici de reprsenter un tel nombre par une liste [rm , rm1 , . . . , r1 , r0 ]. Lalgoe
rithme de conversion consiste ` diviser successivement le nombre n par la base b (n = bq +r) tant
a
Remarque A.5 : Voir aussi lexemple 3.1 page 100 et

les TD 3.1 page 100, 3.3 page 112 et 3.4 page 113.
210
que le quotient q nest pas nul. Lordre inverse des restes des direntes divisions (du dernier au
e
premier reste, crits de gauche ` droite) donne la reprsentation du nombre n en base b.
e
a
e
n
n
n
n
=
=
=
=
q 0 b + r0 = q 0 b1 + r0 b0
(q1 b1 + r1 )b1 + r0 b0 = q1 b2 + r1 b1 + r0 b0
(q2 b1 + r2 )b2 + r1 b1 + r0 b0 = q2 b3 + r2 b2 + r1 b1 + r0 b0
...
i=m
ri bi
n = 0 bm+1 + rm bm + . . . + r2 b2 + r1 b1 + r0 b0 =
i=0
n = (rm rm1 . . . r1 r0 )b
>>>
[2,
>>>
[1,
>>>
[3,
>>>
[1,
>>>
[1,
conversion(23,10)
3]
conversion(23,2)
1, 1, 0, 1]
conversion(23,5)
4]
conversion(23,12)
11]
conversion(23,16)
7]
Algorithme A.3 Conversion en base b

1
2
3
4
5
6
7
8
def conversion (n , b ):
code = []
if n == 0:
code = [0]
while n != 0:
code . insert (0 , n % b )
n = n/b
return code
Courbe fractale de Koch

Remarque A.6 :
Voir aussi le TD 3.12 page 126.
La courbe de von Koch est lune des premi`res courbes fractales ` avoir t dcrite par le
e
a
ee e
mathmaticien sudois Helge von Koch (1870-1924). On peut la crer ` partir dun segment de
e
e
e a
droite, en modiant rcursivement chaque segment de droite de la faon suivante :
e
c
1. on divise le segment de droite en trois segments de longueurs gales,
e
2. on construit un triangle quilatral ayant pour base le segment mdian de la premi`re
e
e
e
e
tape,
e
3. on supprime le segment de droite qui tait la base du triangle de la deuxi`me tape.
e
e
e
211
Avec les instructions ` la Logo (voir annexe 2.6.1 page 91), on obtient lalgorithme rcursif
a
e
ci-dessous pour dessiner de telles courbes (gure A).
Courbes de von Kock pour n = 0 (courbe du bas), n = 1

(courbe du milieu) et n = 2 (courbe du haut).
Algorithme A.4 Courbe fractale de Koch

1
2
3
4
5
6
7
8
9
10
11
def kock (n , d ):
if n == 0: forward ( d )
else :
kock (n -1 , d /3.)
left (60)
kock (n -1 , d /3.)
right (120)
kock (n -1 , d /3.)
left (60)
kock (n -1 , d /3.)
return
Crible dEratosth`ne
e
`
Le crible dEratosth`ne (mathmaticien grec du 3eme si`cle avant JC) est un algorithme pour
e
e
e
trouver tous les nombres premiers infrieurs ` un certain entier naturel donn n. On forme une
e
a
e
liste avec tous les entiers naturels compris entre 2 et n (range(2,n+1)) et on supprime les uns
apr`s les autres, les entiers qui ne sont pas premiers de la mani`re suivante : on commence par
e
e
le dbut de la liste et d`s que lon trouve un entier qui na pas encore t supprim, il est dclar
e
e
ee
e
e
e
premier, on le supprime ainsi que tous les autres multiples de celui-ci et on recommence tant
que la liste nest pas vide. Lalgorithme rcursif suivant le gnralise ` toutes listes, tries par
e
e e
a
e
ordre croissant, dentiers suprieurs ou gaux ` 2.
e
e
a
Les ocons de Koch sobtiennent de la mme faon que

e
c
les courbes fractales, en partant dun polygone rgulier au
e
lieu dun segment de droite.
Ci-dessous, les ocons heptagonaux pour n = 0 (ocon
de gauche), n = 1 (ocon du milieu) et n = 2 (ocon de
droite).
212

def crible(t):
if t[0]**2 > t[-1]: premiers = t
else:
premiers = []
for element in t:
if element%t[0] != 0:
premiers.append(element)
premiers = t[:1] + crible(premiers)
return premiers
>>> crible(range(2,14))
[2, 3, 5, 7, 11, 13]
>>> crible(range(2,100))
[2, 3, 5, 7, 11, 13, 17, 19, 23,
29, 31, 37, 41, 43, 47, 53, 59,
61, 67, 71, 73, 79, 83, 89, 97]
>>> crible(range(2,14,3))
[2, 5, 11]
Un algorithme itratif correspondant est prsent ci-dessous.

e
e
e
Algorithme A.5 Crible dEratost`ne
e
1
2
3
4
5
6
7
8
9
def crible ( t ):
i = 0
while i < len ( t ):
j = i +1
while j < len ( t ):
if t [ j ]% t [0] == 0: del t [ j ]
else : j = j + 1
i = i + 1
return t
Dveloppement limit de la fonction sin(x)

e
e
les TD 2.14 page 55 et 2.40 page 73.
Les dveloppements limits des fonctions usuelles scrivent sous la forme de dveloppements
e
e
e
e
n
en srie enti`re
e
e
uk comme par exemple pour la fonction sinus :

k=0
n
sin(x)
(1)k
uk =
k=0
k=0
x2k+1
x3
x5
x2n+1
=x
+
+ . . . + (1)n
(2k + 1)!
6
120
(2n + 1)!
Ces dveloppements font souvent intervenir les fonctions puissance et factorielle qui sont tr`s
e
e
gourmandes en temps de calcul ; on cherche alors ` viter leur utilisation en sappuyant sur
ae
213
une relation de rcurrence entre les uk . Ainsi, pour la fonction sinus :
e
uk+1 = (1)k+1
x2(k+1)+1
x2k+1
x2
x2
= (1)k
= uk
(2(k + 1) + 1)!
(2k + 1)! (2k + 2)(2k + 3)
(2k + 2)(2k + 3)
Ce qui conduit ` lalgorithme itratif ci-dessous.

a
e
Algorithme A.6 Dveloppement limit
e
e
1
2
3
4
5
6
7
def sinus (x , n ):
u = x
y = u
for k in range (0 , n +1):
u = -(( x * x )/((2* k +2)*(2* k +3)))* u
y = y + u
return y
>>> sinus(pi/6,3)
0.50000000002027989
>>> sinus(pi/2,3)
1.0000035425842861
>>> sinus(pi,3)
0.0069252707075050518
>>> sinus(pi/6,7)
0.49999999999999994
>>> sinus(pi/2,7)
1.0000000000000437
>>> sinus(pi,7)
2.2419510632012503e-08
>>> sinus(pi/6,70)
0.49999999999999994
>>> sinus(pi/2,70)
1.0000000000000002
>>> sinus(pi,70)
2.4790606856821868e-16
Remarque A.8 :
1
sin( ) =
6
2
Rappels :
sin( ) = 1
2
sin() = 0
Fonction factorielle
La fonction factorielle qui calcule le produit des n premiers entiers positifs est simplement
dnie par la relation de rcurrence :
e
e
0! = 1
n! = n (n 1)! n N
n! =
k
k=1
Cette relation de rcurrence est implmente de mani`re rcursive de la mani`re suivante :

e
e
e
e
e
e

les TD 2.13 page 54 et 2.23 page 62.
214

def factorielle(n):
if n < 2: u = 1
else: u = n * factorielle(n-1)
return u
>>> factorielle(0)
1
>>> factorielle(5)
120
>>> factorielle(10)
3628800
Lalgorithme itratif du calcul de n! est donn ci-dessous.

e
e
Algorithme A.7 Fonction factorielle
1
2
3
4
5
def factorielle ( n ):
u = 1
for i in range (2 , n +1):
u = u * i
return u
Fonction puissance
Remarque A.10 : Voir aussi lexemple 2.11 page 54
et le TD 3.17 page 131.
La puissance enti`re p dun nombre x est dnie par : p = xn =

e
e
x = x x x x . On
k=1
n fois
peut la dnir de mani`re rcursive comme ci-dessous :

e
e
e
def puissance(x,n):
if n == 0: p = 1
else: p = x * puissance(x,n-1)
return p
>>> puissance(2,0)
1
>>> puissance(2,20)
1048576
Lalgorithme itratif du calcul de xn est le suivant.

e
Algorithme A.8 Fonction puissance
1
2
3
4
5
def puissance (x , n ):
p = x
for k in range (1 , n ):
p = p*x
return p
215
Nombres de Fibonacci
Les nombres de Fibonacci sont donns par la suite dnie par la relation de rcurrence
e
e
e
ci-dessous :
f0 = f1 = 1
fn = fn1 + fn2 n > 1
Les 10 premiers nombres de la suite de Fibonacci valent donc successivement f0 = 1, f1 = 1,
f2 = 2, f3 = 3, f4 = 5, f5 = 8, f6 = 13, f7 = 21, f8 = 34, et f9 = 55.
`
Le neme nombre de Fibonacci peut donc se calculer de mani`re rcursive en appliquant
e
e
simplement la dnition de la suite de Fibonacci.
e
def fibonacci(n):
if n < 2: f = 1
else: f = fibonacci(n-1) + fibonacci(n-2)
return f
Un algorithme itratif du calcul du

e
`
neme
>>> for n in range(0,10):

print fibonacci(n),
1 1 2 3 5 8 13 21 34 55
nombre de Fibonacci est prsent ci-dessous.

e
e
Algorithme A.9 Nombres de Fibonacci

1
2
3
4
5
6
7
def fibonacci ( n ):
f , f1 , f2 = 2 ,1 ,1
for i in range (3 , n +1) :
f2 = f1
f1 = f
f = f1 + f2
return f
Palindrome
Un palindrome est une squence dont lordre des lments reste le mme quon la parcourt du
e
ee
e
premier au dernier ou du dernier au premier. Ainsi, [1,2,2,1], "kayak" sont des palindromes
au mme titre que lexpression arithmtique 1234+8765=9999=5678+4321. Dans les cha
e
e
nes de
caract`res, si lon ne prend pas en compte la casse (minuscules ou majuscules), les espaces, les
e
signes de ponctuation et les signes diacritiques (accents, cdilles), alors "engage le jeu que
e
je le gagne" et "A man, a plan, a canal : Panama" sont galement des palindromes.
e
Remarque A.11 : Voir aussi lexemple 3.4 page 104,

les gures 3.13 page 112 et 3.14 page 122 et la remarque
3.3 page 113.
216

Algorithme A.10 Palindrome
1
2
3
4
5
6
def palindrome ( t ):
n , i , ok = len ( t ) , 0 , True
while i < n /2 and ok == True :
if t [ i ] != t [n -1 - i ]: ok = False
else : i = i + 1
return ok
Produit de matrices
Remarque A.12 :
Le produit C de 2 matrices A et B respectivement de dimensions (n, r) et (r, m) est tel que :
Remarque A.13 : Le produit de deux matrices nest

dni que si le nombre r de colonnes de la premi`re mae
e
trice est gal au nombre de lignes de la deuxi`me matrice.
e
e
r1
aik bkj
ci,j =
k=0
Algorithme A.11 Produit de matrices

1
2
3
4
5
6
7
8
9
10
11
def produitMatrice (a , b ):
c = []
n ,r , m = len ( a ) , len ( a [0]) , len ( b [0])
for i in range ( n ):
c . append ([])
for j in range ( m ):
x = 0
for k in range ( r ):
x = x + a [ i ][ k ]* b [ k ][ j ]
c [ i ]. append ( x )
return c
>>> a = [[1,2],[3,4]]
>>> b = [[2,1],[-1,-2]]
>>> produitMatrice(a,b)
[[0, -3], [2, -5]]
>>> a = [[1,2,3,4]]
>>> b = [[1],[2],[3],[4]]
>>> produitMatrice(a,b)
[[30]]
217
Il sagit dun algorithme de recherche dun lment x dans une liste t dj` trie. Le principe
ee
ea e
de la recherche dichotomique consiste ` comparer x avec llment t[m] du milieu de la liste t
a
ee
trie :
e
si x == t[m], on a trouv une solution et la recherche sarrte ;
e
e
si x < t[m], x ne peut se trouver que dans la moiti gauche de la liste t puisque celle-ci est
e
trie par ordre croissant ; on poursuit alors la recherche de la mme mani`re uniquement
e
e
e
dans la moiti gauche de la liste ;
e
si x > t[m], x ne peut se trouver que dans la moiti droite de la liste t ; on poursuit alors
e
la recherche uniquement dans la moiti droite de la liste.
e
Remarque A.14 : Voir aussi la section 4.3.2 page 172

consacre ` la recherche dichotomique.
e a
Algorithme A.12 Recherche dichotomique

1
2
3
4
5
6
7
8
def rec h e r c h e D i c h o t o m i q u e (t , x ):
ok , m = False , ( gauche + droite )/2
while gauche <= droite and not ok :
m = ( gauche + droite )/2
if t [ m ] == x : ok = True
elif t [ m ] > x : droite = m - 1
else : gauche = m + 1
return ok , m
e
La recherche squentielle dun lment x dans une liste t consiste ` comparer llment
e
ee
a
ee
recherch x successivement ` tous les lments de la liste t jusqu` trouver une correspondance.
e
a
ee
a
Algorithme A.13 Recherche squentielle
e
1
2
3
4
5
def rec h e r c h e S e q u e n t i e l l e (t ,x , debut , fin ):

ok , r = False , debut
while r <= fin and not ok :

consacre ` la recherche squentielle.
e a
e
218
6
7
8

if t [ r ] == x : ok = True
else : r = r + 1
return ok , r
Tours de Hano
Remarque A.16 : Voir aussi lexemple 3.5 page 123

et le TD 3.9 page 123.
Etat initial :
dpart
intermdiaire
arrive
intermdiaire
Les tours de Hano est un jeu qui consiste ` dplacer n disques de diam`tres dirents
a e
e
e
dune tour de dpart ` une tour d arrive en passant par une tour intermdiaire et
e
a
e
e
ceci en un minimum de coups, tout en respectant les r`gles suivantes :
e
on ne peut dplacer quun disque ` la fois,
e
a
on ne peut placer un disque que sur un autre disque plus grand que lui ou sur une tour
vide.
Dans ltat initial, les n disques sont placs sur la tour dpart . Dans ltat nal, tous les
e
e
e
e
disques se retrouvent placs dans le mme ordre sur la tour arrivee .
e
e
e
arrive
Etat nal :
Algorithme A.14 Tours de Hano
dpart
1
2
3
4
5
6
def hanoi (n , gauche , milieu , droite ):

if n > 0:
hanoi (n -1 , gauche , droite , milieu )
deplacer (n , gauche , droite )
hanoi (n -1 , milieu , droite , gauche )
return
Si le dplacement se traduit par un simple achage du type : dplacer disque n de la tour

e
e
gauche ` la tour droite , alors lappel de la procdure hanoi pour n = 3 produit les
a
e
sorties suivantes.
def deplacer(n,gauche,droite):
print dplacer disque, n,
e
de la tour, gauche,
` la tour, droite
a
return
>>> hanoi(3,d,i,a)
e
e
e
e
e
e
e
d
d
a
d
i
i
d
a
`
a
`
a
`
a
`
a
`
a
`
a
`
la
la
la
la
la
la
la
tour
tour
tour
tour
tour
tour
tour
a
i
i
a
d
a
a
219
Tri bulles
Dans le tri bulles, on parcourt la liste en commenant par la n, en eectuant un change `
c
e
a
chaque fois que lon trouve deux lments successifs qui ne sont pas dans le bon ordre.
ee
Algorithme A.15 Tri bulles
1
2
3
4
5
6
7
def triBulles (t , debut , fin ):

while debut < fin :
for j in range ( fin , debut , -1):
if t [ j ] < t [j -1]:
t [ j ] , t [j -1] = t [j -1] , t [ j ]
debut = debut + 1
return t
>>> s = [9,8,7,6,5,4]
>>> triBulles(s,0,len(s)-1)
[4, 5, 6, 7, 8, 9]
>>> s = [9,8,7,6,5,4]
>>> triBulles(s,1,4)
[9, 5, 6, 7, 8, 4]
Tri fusion
Dans le tri fusion, on partage la liste ` trier en deux sous-listes que lon trie, et on interclasse
a
(on fusionne) ces deux sous-listes.
Algorithme A.16 Tri fusion
1
2
3
4
5
6
7
def triFusion (t , debut , fin ):

if debut < fin :
m = ( debut + fin )/2
triFusion (t , debut , m )
triFusion (t , m +1 , fin )
fusion (t , debut ,m , fin )
return t
La fusion consiste ` construire, ` partir des deux sous-listes tries (la premi`re de lindice
a
a
e
e
debut ` lindice k, la deuxi`me de lindice k+1 ` lindice fin) une liste elle-mme trie des indices
a
e
a
e
e
debut ` fin et contenant lensemble des lments des deux sous-listes dorigine.
a
ee
Remarque A.17 :
Remarque A.18 : Le nom du tri bulles vient de ce que

les lments les plus petits (les plus lgers ) remontent
ee
e
vers le dbut de la liste comme des bulles vers le haut
e
dune bouteille deau gazeuse.
220

Fusion
1
2
3
4
5
6
7
8
9
def fusion (t , debut ,k , fin ):

i1 , i2 = debut , k +1
while i1 <= k and i2 <= fin :
if t [ i2 ] >= t [ i1 ]: i1 = i1 + 1
else :
t [ i1 ] , t [ i1 +1: i2 +1] = t [ i2 ] , t [ i1 : i2 ]
k = k + 1
i2 = i2 + 1
return t
>>> s = [4,5,6,1,2,3]
>>> fusion(s,0,2,len(s)-1)
[1, 2, 3, 4, 5, 6]
>>> s = [4,5,6,1,2,3]
>>> fusion(s,1,2,4)
[4, 1, 2, 5, 6, 3]
Tri par insertion

consacre au tri par insertion.
e
`
Dans le tri par insertion, on trie successivement les premiers lments de la liste : ` la ieme
ee
a
`
tape, on ins`re le ieme lment ` son rang parmi les i 1 lments prcdents qui sont dj`
e
e
ee
a
ee
e e
ea
tris entre eux.
e
Algorithme A.17 Tri par insertion

1
2
3
4
5
6
7
8
9
10
11
def triInsertion (t , debut , fin ):

for k in range ( debut +1 , fin +1):
i = k - 1
x = t[k]
while i >= debut and t [ i ] > x :
t [ i +1] = t [ i ]
i = i - 1
t [ i +1] = x
return t
221
Tri par slection

e
Le tri par slection dune liste consiste ` rechercher le minimum de la liste ` trier, de le
e
a
a
mettre en dbut de liste en lchangeant avec le premier lment et de recommencer sur le reste
e
e
ee
de la liste.

consacre au tri par slection.
e
e
Algorithme A.18 Tri par slection

e
1
2
3
4
5
6
7
8
def triSelection (t , debut , fin ):

while debut < fin :
mini = minimum (t , debut , fin )
t [ debut ] , t [ mini ] = t [ mini ] , t [ debut ]
debut = debut + 1
return t
Tri rapide
Le principe du tri rapide est le suivant : on partage la liste ` trier en deux sous-listes telles que
a
tous les lments de la premi`re soient infrieurs ` tous les lments de la seconde. Pour partager
ee
e
e
a
ee
la liste en deux sous-listes, on choisit un des lments de la liste (par exemple le premier) comme
ee
pivot. On construit alors une sous-liste avec tous les lments infrieurs ou gaux ` ce pivot et
ee
e
e
a
une sous-liste avec tous les lments suprieurs au pivot. On trie les deux sous-listes selon le
ee
e
mme processus jusqu` avoir des sous-listes rduites ` un seul lment.
e
a
e
a
ee
Algorithme A.19 Tri rapide
1
2
3
4
5
6
7
def triRapide (t , debut , fin ):

assert 0 <= debut
assert fin <= len ( t )
if debut < fin :
pivot = t [ debut ]
place = partition (t , debut , fin , pivot )

consacre au tri rapide.
e
222
8
9
10

triRapide (t , debut , place -1)
triRapide (t , place +1 , fin )
return t
Partition
1
2
3
4
5
6
7
8
9
10
11
12
13
def partition (t , debut , fin , pivot ):

place , inf , sup = debut , debut , fin ;
while place <= sup :
if t [ place ] == pivot : place = place + 1
elif t [ place ] < pivot :
t [ inf ] , t [ place ] = t [ place ] , t [ inf ]
inf = inf + 1
place = place + 1
else :
t [ sup ] , t [ place ] = t [ place ] , t [ sup ]
sup = sup - 1
if place > 0: place = place - 1
return place
>>> s = [3,6,5,4,1,2]
>>> partition(s,0,len(s)-1,4), s
(3, [3, 2, 1, 4, 5, 6])
>>> s = [3,6,5,4,1,2]
>>> partition(s,1,4,4), s
(2, [3, 1, 4, 5, 6, 2])
Annexe B
Travaux dirigs
e
Le planning prvisionnel de la section 1.6.3 page 34 permet de visualiser la rpartition des 7
e
e
sances de travaux diriges organises au cours des 15 semaines du cours dInformatique S1 de
e
e
e
lENIB. Dans cette annexe, on prcise pour chaque TD
e
1. les objectifs recherchs,
e
2. les exercices de TD ` prparer avant la sance,
a e
e
3. les exercices complmentaires pour sexercer.
e
TD 1
Objectifs
1. Prise en main de lenvironnement informatique (syst`me dexploitation Linux, environnee
ment de programmation Python, site Web) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1h30
2. Exploitation des instructions de base : aectation et tests (chapitre 2, sections 2.2 et 2.3
page 46) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1h30
223

ANNEXE B. TRAVAUX DIRIGES
224
Exercices de TD
Affectation
TD 2.1
TD 2.2
TD 2.3
TD 2.4
Unit de pression. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
Suite arithmtique (1). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
Permutation circulaire (1). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Squence daectations (1). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
42
44
45
45
2.5 Oprateurs boolens. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

e
e
2.6 Circuits logiques (1). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.7 Lois de De Morgan. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.8 Maximum de 2 nombres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.9 Fonction porte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.10 Ouverture dun guichet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.11 Catgorie sportive. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
47
47
48
49
49
50
51
Tests
TD
TD
TD
TD
TD
TD
TD
e
Comprendre
TD 2.26
TD 2.27
TD 2.28
TD 2.29
TD 2.30
TD 2.31
TD 2.32
Unit de longueur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
Permutation circulaire (2). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Squence daectations (2). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
Circuits logiques (2). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Alternative simple et test simple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Racines du trinome. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Squences de tests. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
66
66
66
67
70
70
70
Appliquer
TD 2.35
TD 2.36
TD 2.37
TD 2.38
TD 2.39
Figures gomtriques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e e
Suites numriques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
Calcul vectoriel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Prix dune photocopie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Calcul des impts. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
o
72
73
73
73
73
225
Analyser
TD 2.42 Dessins gomtriques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
e e
TD 2.43 Police dassurance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
TD 2
Objectifs
1. Exploitation des instructions de base : boucles (chapitre 2, section 2.4) . . . . . . . . . . . . . . 3h
Exercices de TD
Boucles
TD
TD
TD
TD
TD
TD
TD
TD
TD
TD
TD
TD
TD
2.12
2.13
2.14
2.15
2.16
2.17
2.18
2.19
2.20
2.21
2.22
2.23
2.24
Dessin dtoiles (1). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

e
Fonction factorielle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fonction sinus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Algorithme dEuclide. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Division enti`re. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
Achage inverse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Parcours inverse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Suite arithmtique (2). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
Dessin dtoiles (2). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
Oprateurs boolens drivs (2). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
e
e e
Damier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Trace de la fonction factorielle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Figure gomtrique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e e
53
54
55
56
56
58
58
58
59
60
61
62
62
e
Comprendre
TD 2.33 Racine carre enti`re. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
e
e
TD 2.34 Excutions dinstructions itratives. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
e
e
Appliquer
TD 2.40 Dveloppements limits. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
e
e

226
TD 2.41 Tables de vrit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

e e
Analyser
TD 2.44 Zro dune fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
e
TD 3
Objectifs
1. Exploitation des instructions de base : aectation, tests et boucles imbriqus (chapitre 2
e
en entier) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3h
Exercices de TD
Il sagit dun TD rcapitulatif sur les instructions de base, aussi les exercices ` prparer font partie des exercices
e
a e
complmentaires des TD prcdents.
e
e e
TD 2.40 Dveloppements limits. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

e
e
TD 2.41 Tables de vrit. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
e e
TD 2.44 Zro dune fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
e
TD 4
Objectifs
1. Spcier et implmenter des fonctions (chapitre 3, section 3.2) . . . . . . . . . . . . . . . . . . . . . . 3h
e
e
Exercices de TD
TD
TD
TD
TD
TD
3.1
3.2
3.3
3.4
3.5
Codage des entiers positifs (1). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Codage dun nombre fractionnaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dcodage base b dcimal. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
e
Codage des entiers positifs (2). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Une spcication, plusieurs implmentations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
e
100
101
112
113
114
227
e
Analyser
TD 3.20
TD 3.21
TD 3.22
TD 3.23
TD 3.24
Addition binaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Complment ` 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
a
Codage-dcodage des rels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
e
Intgration numrique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
e
Tracs de courbes paramtres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
e e
132
132
133
134
136
TD 5
Objectifs
1. Spcier et implmenter des fonctions (chapitre 3, section 3.2) . . . . . . . . . . . . . . . . . . . . . . 3h
e
e
Exercices de TD
Il sagit dun TD rcapitulatif sur la dnition des fonctions, aussi les exercices ` prparer font partie des exercices
e
e
a e
complmentaires des TD prcdents.
e
e e
e
e
TD 3.23 Intgration numrique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
TD 3.24 Tracs de courbes paramtres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
e
e e
TD 6
Objectifs
1. Appeler des fonctions itratives ou rcursives (chapitre 3, section 3.3) . . . . . . . . . . . . . . . 3h
e
e
Exercices de TD
TD
TD
TD
TD
3.6
3.7
3.8
3.9
Passage par valeur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Valeurs par dfaut. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
Porte des variables (1). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
Tours de Hano ` la main. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
a
116
119
121
123

228
TD 3.10 Pgcd et ppcm de 2 entiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

TD 3.11 Somme arithmtique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
e
TD 3.12 Courbes fractales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
e
Comprendre
TD 3.14
TD 3.15
Appliquer
TD 3.16
TD 3.17
TD 3.18
TD 3.19
Passage des param`tres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

e
Porte des variables (2). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
e
Suite gomtrique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e e
Puissance enti`re. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
Coecients du binme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
o
Fonction dAckerman. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
131
131
131
132
TD 7
Objectifs
1. Manipulation de squences (chapitre 4, section 4.2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3h
e
Exercices de TD
N-uplets
TD 4.2 Oprations sur les n-uplets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
TD 4.3 Pgcd et ppcm de 2 entiers. (2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
`
Cha
nes de caracteres
TD 4.4 Oprations sur les cha
e
nes de caract`res. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
TD 4.5 Inverser une cha
ne. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
TD 4.6 Caract`res, mots, lignes dune cha
e
ne. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Listes
TD 4.7 Oprations sur les listes. (1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
TD 4.8 Oprations sur les listes. (2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
TD 4.9 Slection dlments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
ee
163
163
164
164
165
165
166
166
229
Piles et files
TD 4.10 Oprations sur les piles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
e
TD 4.11 Oprations sur les les. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
e
Listes multidimensionnelles
TD 4.12 Produit de matrices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
e
Comprendre
TD 4.21 Gnration de squences. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
e e
e
TD 4.22 Application dune fonction ` tous les lments dune liste. . . . . . . . . . . . . . . . 182
a
ee
TD 4.23 Que fait cette procdure ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
e
Appliquer
TD 4.24 Codes ASCII et cha
nes de caract`res. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
e
TD 4.25 Oprations sur les matrices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
e
Analyser
TD 4.26
TD 4.27
TD 4.28
TD 4.29
Recherche dun motif. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Recherche de toutes les occurences. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Tri bulles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Mthode dlimination de Gauss. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
e
e
184
184
184
184
Evaluer
TD 4.30 Comparaison dalgorithmes de recherche. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
TD 4.31 Comparaison dalgorithmes de tri. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
230
Annexe C
Contrles types
o
Cette annexe propose des exemples corrigs de contrles dautoformation (CAF) et de
e
o
contrles de comptences (DS) tels quils sont programms au cours du semestre S1 (voir le
o
e
e
planning prvisionnel en section 1.6.3 page 34). Lesprit de ces contrles est rsum dans le
e
o
e
e
chapitre 1 dintroduction ` la section 1.3.3 page 14.
a
Quel que soit le type de contrle, un exercice cherche ` valuer un objectif particulier. Aussi,
o
ae
la notation exprimera la distance qui reste ` parcourir pour atteindre cet objectif (gure C) :
a
0
1
2
3
:
:
:
:
en plein dans le mille !

pas mal !
juste au bord de la cible !
la cible nest pas touche !
e
lobjectif est atteint

on se rapproche de lobjectif
on est encore loin de lobjectif
lobjectif nest pas atteint
Ainsi, et pour changer de point de vue sur la notation, le contrle est russi lorsquon a 0 ! Il
o
e
ny a pas non plus de 1/2 point ou de 1/4 de point : le seul barme possible ne comporte que 4
e
niveaux : 0, 1, 2 et 3. On ne cherche donc pas ` grappiller des points :
a
on peut avoir 0 (objectif atteint) et avoir fait une ou deux erreurs bnignes en regard de
e
lobjectif recherch ;
e
on peut avoir 3 (objectif non atteint) et avoir quelques lments de rponse corrects mais
ee
e
sans grand rapport avec lobjectif.
231
Sommaire
CAF1 : calculs boolens . . . . . . . . . . . . . . . . . .
e
CAF2 : codage des nombres . . . . . . . . . . . . . .
CAF3 : recherche dun lment . . . . . . . . . .
ee
DS1 : instructions de base . . . . . . . . . . . . . . . .
DS2 : procdures et fonctions . . . . . . . . . . . .
e
232
234
236
239
243
Notation : la mtaphore de la cible.

e
0
1
2
3
Remarque C.1 : Une absence ` un contrle conduit `
a
o
a
la note 4 ( la cible nest pas vise ).
e

ANNEXE C. CONTROLES TYPES
232
CAF1 : calculs boolens

e
Dveloppement dune expression boolenne
e
e
Dvelopper lexpression boolenne suivante :
e
e
t=abcd
t =
=
=
=
=
abcd
(a b) (c d)
ab+cd
(a + b) + (c + d)
a+b+c+d
associativit
e
De Morgan
De Morgan
associativit
e
Table de vrit dune expression boolenne

e e
e
Etablir la table de vrit de lexpression boolenne suivante :
e e
e
t = ((a b) (b c)) (c a)
On pose u = (a b) (b c) :
a
0
0
0
0
1
1
1
1
b
0
0
1
1
0
0
1
1
c (a b) (b c)
1
1
0
1
1
1
0
1
0
1
1
1
0
0
1
1
0
1
0
1
0
1
1
1
u
1
1
0
1
0
0
0
1
c
1
0
1
0
1
0
1
0
a (c a)
1
1
1
1
1
1
1
1
0
0
0
1
0
0
0
1
t
1
1
1
1
1
1
1
1
233
Table de vrit dun circuit logique

e e
On consid`re les conventions graphiques traditionnelles pour les oprateurs logiques , + et :
e
e
ab
a+b
ab
Etablir la table de vrit du circuit logique ci-dessous o` a, b et c sont les entres, x et y les
e e
u
e
sorties.
a
b
c
a
0
0
0
0
1
1
1
1
b
0
0
1
1
0
0
1
1
c (b c) (b c) (a (b c))
0
0
0
0
1
0
1
0
0
0
1
0
1
1
0
0
0
0
0
0
1
0
1
1
0
0
1
1
1
1
0
0
x
0
1
1
0
1
0
0
1
y
0
0
0
1
0
1
1
1
Il sagit de laddition des 3 bits a, b et c : x est la somme et y la retenue

a
b
c
yx
0
0
0
00
0
0
1
01
0
1
0
01
0
1
1
10
1
0
0
01
1
0
1
10
1
1
0
10
1
1
1
11

234
CAF2 : codage des nombres

Reprsentation en complment ` 2
e
e
a
1. Dterminer la plage de valeurs enti`res possibles lorsquun entier positif, ngatif ou nul est
e
e
e
cod en binaire sur k = 4 chires dans la reprsentation en complment ` 2.
e
e
e
a
Lors dun codage en binaire sur k bits, seuls les nombres entiers relatifs n tels
que 2k1 n < 2k1 peuvent tre reprsents (n [2k1 ; 2k1 [).
e
e
e
Application numrique : k = 4 : [241 ; 241 [ = [8; +8[
e
2. Coder lentier n = (93)10 sur k = 8 chires en base b = 2 en utilisant la reprsentation
e
du complment ` 2.
e
a
(a) coder |n| = (93)10 sur (k 1) = 7 chires : (93)10 = (1011101)2

`
(b) mettre le bit de poids fort (k eme bit) ` 0 : (01011101)2
a
(c) inverser tous les bits obtenus : (01011101)2 (10100010)2

(d) ajouter 1 : (10100010)2 + (00000001)2 = (10100011)2
(e) conclusion : n = (93)10 = (10100011)2
3. Vrier la rponse prcdente en additionnant en base b = 2, n et (n), cods sur k = 8
e
e
e e
e
chires dans la reprsentation du complment ` 2.
e
e
a
n = (93)10 =
(10100011)2
+ (n) = (+93)10 =
(01011101)2
0 =
(0)10 =
1(00000000)2
`
Le bit de poids fort (le 9eme bit ` partir de la droite : 1) est perdu.
a
235
IEEE 754 simple prcision

e
Coder le nombre rel x = 73.25 selon la norme IEEE 754 en simple prcision.
e
e
partie enti`re : : (73)10 = (1001001)2

e
partie fractionnaire : (0.25)10 = (0.01)2
mantisse normalise : (1001001.01)2 = (1.00100101)2 26 = (1.00100101)2
e
2(00000110)2
exposant relatif ` 127 : (01111111)2 + (00000110)2 = (10000101)2
a
signe : (1)2
norme IEEE 754 :
1 1 0 0 0 0 1 0 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

236
CAF3 : recherche dun lment

ee
Recherche dune occurrence
`
Dnir une fonction rechercheKieme qui recherche le rang r de la keme occurrence dun
e
lment x ` partir du dbut dune liste t.
ee
a
e
Exemple : t = [7,4,3,2,4,4], k = 2, x = 4 r = 4
1
2
3
4
5
6
def rechercheKieme (t ,x , k ):
"""
recherche la ki` me occurrence de x dans le tableau t
e
-> ( found , index )
( found == False and index == len ( t )) or
( found == True and 0 <= index < len ( t ))
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
>>> rechercheKieme ([] ,7 ,2)

( False , 0)
>>> rechercheKieme ([1 ,2 ,3 ,2] ,7 ,2)
( False , 4)
>>> rechercheKieme ([1 ,2 ,3 ,2] ,2 ,2)
( True , 3)
"""
assert type ( k ) is int
found , index , occur = False , 0 , 0
while index < len ( t ) and not found :
if t [ index ] == x :
occur = occur + 1
if occur == k : found = True
else : index = index + 1
else : index = index + 1
return found , index
237
Excution dune fonction

e
On consid`re la fonction g ci-dessous.
e
1
2
3
4
def g (t ,x ,k , d ):
assert type ( k ) is int and k > 0
assert d in [0 ,1]
5
6
7
8
9
10
11
12
13
14
15
ok , i , n = False , (1 - d )*( len ( t ) -1) , 0

print i ,n , ok # - - - - - - - - - - - - - - - - - - - - - - - - - - affichage
while i in range (0 , len ( t )) and not ok :
if t [ i ] == x :
n = n + 1
if n == k : ok = True
else : i = i - ( -1)** d
else : i = i - ( -1)** d
print i ,n , ok # - - - - - - - - - - - - - - - - - - - - - - affichage
print i ,n , ok # - - - - - - - - - - - - - - - - - - - - - - - - - - affichage
16
17
return ok , i
1. Quache lappel g(t,2,3,0) quand t = [5,2,5,3,5,2,5,2] ?

>>> t = [5,2,5,3,5,2,5,2]
>>> g(t,2,3,0)
7 0 False
6 1 False
5 1 False
4 2 False
3 2 False
2 2 False
1 2 False
1 3 True
1 3 True
(True, 1)

238
2. Complter la spcication de la fonction g.

e
e
Description :
"""
(ok,i) = g(t,x,k,d)
i est le rang de la k`me occurence de x en partant
e
du dbut (d = 1) ou de la fin (d = 0) de la liste t,
e
si cette occurence existe (ok = True) ;
i = d*len(t) - (1-d) sinon (ok = False)
"""
Jeu de tests :
"""
>>> g([],7,2,0)
(False, -1)
>>> g([],7,2,1)
(False, 0)
>>> g([1,2,3,2,5],2,2,0)
(True, 1)
>>> g([1,2,3,2,5],2,2,1)
(True, 3)
>>> g([1,2,3,2,5],2,3,0)
(False, -1)
>>> g([1,2,3,2,5],2,3,1)
(False, 5)
"""
239
DS1 : instructions de base

Excution dune squence dinstructions
e
e
Quache la squence dinstructions suivante ?
e
a = 289
x = 1
z = a
y = 0
t = x
print a,x,z,t,y
while x <= a: x = x*4
print a,x,z,t,y
t = x
while x > 1:
x = x/4
t = t/2 - x
if t <= z:
z = z - t
t = t + x*2
y = t/2
print a,x,z,t,y
a
289
289
289
289
289
289
289
289
x
1
1024
256
64
16
4
1
1
z
289
289
33
33
33
33
0
0
t
1
1
768
320
144
68
35
35
y
0
0
384
160
72
34
17
17
print a,x,z,t,y
Il sagit du calcul de la racine carre enti`re y dun nombre entier a : y = 17 =

e
e
289 =
a.
Calcul de
Dans cette section, on se propose de calculer selon la mthode des rectangles.
e
Selon cette mthode, on calcule ` partir de lexpression de la surface S dun cercle de rayon
e
a
unit. On approche la surface du quart de cercle par n rectangles daire Ai = yi /n.
e

240
Ecrire un algorithme qui calcule selon la mthode

e
des rectangles ` lordre n.
a
1/n
0
1
x
Les points du cercle de rayon unit ont pour coordonnes xk =

e
e
k
et yk =
n
k2
n2
k2
. La surface du 1/4 de
n2
n
cercle scrit alors comme la somme des rectangles de base : S =

e
=
sk =
4
et un rectangle de base a pour surface sk =
1
n
k=0
1
n
n
k=0
k2
1 2.
n
Ce qui donne avec linterprteur python :

e
>>> n = 20000000
>>> y = 0.
>>> for k in range(0,n+1) :
...
y = y + sqrt(1 - (1.*k*k)/(n*n))
...
>>> pi - 4*y/n
-9.9986801060936159e-08
Zro dune fonction

e
Remarque C.2 :
Voir TD 2.44 page 75.
Dans cette section, on recherche le zro dune fonction f continue sur un intervalle [a, b] telle
e
que f (a).f (b) < 0 (il existe donc une racine de f dans ]a, b[ que nous supposerons unique).
241
Ecrire un algorithme qui dtermine le zro de cos(x) dans [1, 2] selon la mthode des tane
e
e
gentes.
Indications : soit xn une approximation de la racine c recherche : f (c) = f (xn ) + (c
e
xn )f (xn ) ; comme f (c) = 0, on a : c = xn f (xn )/f (xn ). Posons xn+1 = xn f (xn )/f (xn ) :
on peut considrer que xn+1 est une meilleure approximation de c que xn . On recommence le
e
procd avec xn+1 et ainsi de suite jusqu` ce que |xn+1 xn | soit infrieur ` un certain seuil s.
e e
a
e
a

>>> x1 = 1.
>>> x2 = 2.
>>> s = 1.e-9
>>> f = cos
>>> df = sin
>>> x = x2 - f(x2)/(-df(x2))
... x2 = x
... x = x - f(x)/(-df(x))
...
>>> cos(x)
6.1230317691118863e-17
Tableau dIbn al-Banna

Lexercice suivant est inspir du premier chapitre du livre Histoire dalgorithmes [2]. On
e
consid`re ici le texte dIbn al-Banna concernant la multiplication ` laide de tableaux.
e
a
Tu construis un quadrilat`re que tu subdivises verticalement et horizontalement en autant de bandes
e
quil y a de positions dans les deux nombres multiplis. Tu divises diagonalement les carrs obtenus,
e
e
a
` laide de diagonale allant du coin infrieur gauche au coin suprieur droit.
e
e
Tu places le multiplicande au-dessus du quadrilat`re, en faisant correspondre chacune de ses positions
e
a
` une colonne. Puis, tu places le multiplicateur ` gauche ou ` droite du quadrilat`re, de telle sorte
a
a
e
quil descende avec lui en faisant correspondre galement chacune de ses positions ` une ligne. Puis,
e
a
tu multiplies, lune apr`s lautre, chacune des positions du multiplicande du carr par toutes les
e
e
positions du multiplicateur, et tu poses le rsultat partiel correspondant ` chaque position dans le
e
a
carr o` se coupent respectivement leur colonne et leur ligne, en plaant les units au-dessus de la
e u
c
e
diagonale et les dizaines en dessous. Puis, tu commences ` additionner, en partant du coin suprieur
a
e
gauche : tu additionnes ce qui est entre les diagonales, sans eacer, en plaant chaque nombre dans
c
Remarque C.3 :
Remarque C.4 :
Lcriture du multiplicande seectue de droite `
e
a
gauche (exemple : 352 scrira donc 253).
e
Lcriture du multiplicateur seectue de bas en haut
e
(exemple :
3
5
2
scrira donc
e
2
5
3
).

242
sa position, en transfrant les dizaines de chaque somme partielle ` la diagonale suivante et en les
e
a
ajoutant ` ce qui y gure.
a
La somme que tu obtiendras sera le rsultat.
e
En utilisant la mthode du tableau dIbn al-Banna, calculer 63247 124 (= 7842628).

e
7
8
8
4
2
7
6
2
4
2
1
0
6
8
4
4
2
1
0
0
8
4
2
8
3
0
0
0
2
6
3
7
6
1
0
0
2 4
1 2
0 1
243
DS2 : procdures et fonctions

e
Calcul de
Dnir une fonction qui calcule a lordre n selon la formule :
e
`
4 16 36 64
=2
= 2
3 15 35 63
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
n
k=1
4k 2
4k 2 1
def pi ( n ):
"""
y = pi ( n )
calcule pi ` l ordre n
a
>>> abs ( pi (1) - math . pi ) < 1.
True
>>> abs ( pi (100) - math . pi ) < 1./100
True
>>> abs ( pi (10000000) - math . pi ) < 1. e -7
True
"""
assert type ( n ) is int and n > 0
y = 2.
for k in range (1 , n +1):
u = 4* k * k
y = y * u /( u -1)
return y
Conversion dcimal base b

e
Dnir une fonction qui
e
Exemples pour n = 23 : b
b
b
b
calcule le code t en base b

= 2
k = 7 t = [0,
= 5
k = 5 t = [0,
= 21 k = 2 t = [1,
= 25 k = 6 t = [0,
sur k chires dun entier n.

0, 1, 0, 1, 1, 1]
0, 0, 4, 3]
2]
0, 0, 0, 0, 23]
Remarque C.5 :

244
1
2
3
4
5
6
7
8
9
10
11
12
13
14
def code (n ,b , k ):
"""
c = code (n ,b , k )
code n en base b sur k chiffres
>>> code (23 ,2 ,8)
[0 , 0 , 0 , 1 , 0 , 1 , 1 , 1]
>>> code (23 ,2 ,7)
[0 , 0 , 1 , 0 , 1 , 1 , 1]
>>> code (23 ,5 ,5)
[0 , 0 , 0 , 4 , 3]
>>> code (23 ,21 ,2)
[1 , 2]
>>> code (23 ,25 ,6)
[0 , 0 , 0 , 0 , 0 , 23]
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
"""
assert type ( n ) is int and n >= 0
assert type ( b ) is int and b > 1
assert type ( k ) is int and k > 0
c = []
for i in range ( k ): c . append (0)
q = n
i = k -1
while q > 0 and i >= 0:
r = q%b
q = q/b
c[i] = r
i = i - 1
return c
245
Quinconce
Dnir une procdure qui dessine n m cercles de rayon r disposs en quinconce sur n
e
e
e
ranges de m cercles chacune. On utilisera les instructions de trac ` la Logo.
e
ea
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def quinconce (n ,m , r ):
"""
quinconce (n ,m , r )
trace n rang es de m cercles de rayon r
e
dispos es en quinconce
e
>>> quinconce (5 ,10 ,10)
"""
assert type ( n ) is int and n > 0
assert type ( m ) is int and m > 0
assert type ( r ) is int and r > 0
for i in range ( n ) :
x0 = r *( i %2)
y0 = 2* i * r
for j in range ( m ) :
up ()
goto ( x0 +2* j *r , y0 )
down ()
circle ( r )
return
Remarque C.6 :

246
Coecients de Kreweras
On consid`re la fonction g ci-dessous.
e
1
2
3
4
5
6
7
8
9
10
11
12
13
def g (n , m ):
assert type ( m ) is int
assert 0 <= m and m <= n
if n == 0 and m == 0:
c = 1
else :
if m == 0: c = 0
else :
c = 0
for i in range (1 , m +1):
c = c + g (n -1 ,n - i )
return c
1. Calculer toutes les valeurs possibles de g(n, m) pour n [0, 6].

>>> for n in range(7) :
print n =, n, :,
for m in range(n+1) :
print kreweras(n,m),
print
n
n
n
n
n
n
n
=
=
=
=
=
=
=
0
1
2
3
4
5
6
:
:
:
:
:
:
:
1
0
0
0
0
0
0
1
1 1
1 2 2
2 4 5 5
5 10 14 16 16
16 32 46 56 61 61
247
2. Vrier que 12.*g(5,5)/g(6,6) est une bonne approximation de .
e
>>> 2.*6*g(5,5)/g(6,6)
3.1475409836065573
>>> 2.*12*g(11,11)/g(12,12)
3.1416005461074121
Porte des variables

e
Remarque C.7 :

e
def f(x):
x = 2*x
print f, x
return x
def g(x):
x = 4*f(x)
print g, x
return x
def h(x):
x = 3*g(f(x))
print h, x
return x

1. >>> x = 2
>>> print x
2
>>> y = f(x)
f 4
>>> print x
2
>>> z = g(x)
f 4
g 16
>>> print x
2
>>> t = h(x)
f 4
f 8
g 32
h 96
>>> print x
2
2. >>> x = 2
>>> print x
2
>>> x = f(x)
f 4
>>> print x
4
>>> x = g(x)
f 8
g 32
>>> print x
32
>>> x = h(x)
f 64
f 128
g 512
h 1536
>>> print x
1536

248
Excution dune fonction itrative

e
e
Remarque C.8 :
On consid`re la procdure f dnie ci-dessous.

e
e
e
1
2
3
4
5
6
7
8
9
10
11
def f ( n ):
for p in range ( n +1):
num = 1
den = 1
for i in range (1 , p +1) :
num = num *( n - i +1)
den = den * i
c = num / den
print c , # - - - - - - - - - - - - affichage
print
# - - - - - - - - - - - - affichage
return
1. Quache linstruction for n in range(7) : f(n) ?

>>> for n in range(7) : f(n)
1
1
1
1
1
1
1
1
2
3
4
5
6
1
3 1
6 4 1
10 10 5 1
15 20 15 6 1
2. Que reprsente c ` la n de chaque itration sur p ?

e
a
e
e
Le pi`me coecient du binme (x + y)n avec 0 p n.
o
Index
Ackerman, 132
Bloom, 11
De Morgan, 48
Dijkstra, 177
Dreyfus, 4
`
Eratosthene, 211
Euclide, 208
Gauss, 199
Hoare, 177
Moore, 27
Perret, 4, 31
Simpson, 136
Von Koch, 210
Von Neumann, 5, 257
arbre, 161
bit, 8
boucle
boucles imbriques, 59
e
condition darrt, 97
e
invariant, 98
itration conditionnelle, 52
e
parcours de squence, 58
e
calcul Shadok, 25, 30
cha de caract`res, 164
ne
e
codes ASCII, 194
collection de donnes, 160
e
compilateur, 9
contrle, voir valuation
o
e
aectation, 43
algorithme
complexit, 7, 172
e
dnition, 6
e
ecacit, 7
e
robustesse, 7
rutilisabilit, 7, 100
e
e
validit, 6
e
algorithmique, 6
alternative, voir test
division chinoise, 24, 30

valuation
e
contrle dattention, 14, 20, 63, 128
o
contrle dautoformation, 15, 232, 234,
o
236
contrle de comptence, 15, 239, 243
o
e
contrle de TD, 15
o
ds, voir contrle de comptence
o
e
249
250
INDEX
valuation des enseignements, 16, 33
e
notation, 15
planning des valuations, 34
e
qcm, voir contrle dattention
o
le, 167
fonction
appel quivalent, 116
e
description, 111
dnition, 102
e
espace de noms, 120
implmentation, 104
e
invariant, 108
ordre des param`tres, 120
e
param`tre dentre, 106
e
e
param`tre de sortie, 106
e
param`tre eectif, 116
e
param`tre formel, 115
e
param`tre par dfaut, 119
e
e
passage par rfrence, 117
ee
passage par valeur, 117, 130
postcondition, 108
prcondition, 107
e
qcm, 128
rcursivit, 122
e
e
rcursivit non terminale, 126
e
e
rcursivit terminale, 126
e
e
spcication, 104
e
for, 58
graphe, 161
if, 47
if ... else, 48
if ... elif ... else, 50

informatique, 4
instruction
aectation, 43
alternative multiple, 50
alternative simple, 48
bloc dinstructions, 59
test simple, 47
interprteur, 9
e
itration, voir boucle
e
langage
Logo, 91, 152
Python
bloc dinstructions, 59
documentation, 156
espace de noms, 120
chiers, 198
fonctions, 153, 155
instructions, 41, 92
mots rservs, 43
e
e
oprateurs, 47
e
squences, 57, 194
e
langage de programmation, 9
liste, 165
logiciel, 4
matriel
e
architecture de Von Neumann, 5
cpi, 40
dnition, 4
e
jeu dinstructions, 40
loi de Moore, 27
mips, 21, 26
INDEX
multiplication arabe, 23, 29
multiplication ` la russe , 23, 29
a
n-uplet, 163
norme IEEE 754, 133
octet, 8, 27
oprateurs boolens, 47
e
e
ordinateur, 4, 31
pile, 167
procdure, 103
e
programmation, 8
compilation, 10
interprtation, 10
e
semi-compilation, 10
pdagogie
e
apprendre en faisant, 19
mthodes de travail
e
appropriation, 17, 19
participation, 17, 18
prparation, 16, 18
e
objectifs comportementaux, 12
pdagogie de lerreur, 12
e
pdagogie par lexemple, 12
e
pdagogie par objectifs, 12
e
pdagogie par probl`mes, 12
e
e
taxonomie de Bloom, 11
recherche dans une squence
e
recherche dun motif, 184
recherche dichotomique, 172, 217
recherche squentielle, 171, 217
e
rcursivit, 122
e
e
rptition, voir boucle
e e
251
squence, 160
e
Fifo, 167
Lifo, 167
ne
e
le, 167
liste, 165
n-uplet, 163
pile, 167
test, 46
test simple, 47
tri dune squence
e
tri bulles, 184, 219
tri fusion, 219
tri par insertion, 175, 220
tri par slection, 174, 221
e
tri rapide, 177, 221
tri shell, 186
type abstrait de donnes, 159, 193
e
type de donnes, 159
e
variable
dnition, 42
e
nom de variable, 42
porte, 120, 130
e
type, 159
variable globale, 121
variable locale, 120
while, 52
Dnitions
e
aectation, 43
algorithme, 6
algorithmique, 6
arbre, 161
invariant, 108
invariant de boucle, 98
itration conditionnelle, 52
e
langage de programmation, 9
liste, 165
logiciel, 4
bit, 8
matriel, 4
e

ne
e
collection, 160
compilateur, 9
complexit dun algorithme, 7
e
n-uplet, 163
octet, 8
param`tre dentre, 106
e
e
param`tre de sortie, 106
e
param`tre eectif, 116
e
param`tre formel, 115
e
passage par rfrence, 117
ee
passage par valeur, 117
pile, 167
postcondition, 108
procdure, 103
e
programmation, 9
prcondition, 107
e
description dune fonction, 111

ecacit dun algorithme, 7
e
le, 167
fonction, 102
fonction rcursive, 122
e
graphe, 161
implmentation dun algorithme, 104
e
informatique, 4
interprteur, 9
e
robustesse dun algorithme, 7

252

DEFINITIONS
rcursivit non terminale, 126
e
e
rcursivit terminale, 126
e
e
rutilisabilit dun algorithme, 7
e
e
spcication dun algorithme, 104
e
squence, 57, 160
e
test simple, 47
type, 159
validit dun algorithme, 6
e
variable, 42
253
Exercices
Python, 11, 13, 18
contrle dattention, 14, 17, 20, 63, 128, 180

o
contrle dautoformation, 15, 17, 232, 234,
o
236
contrle de comptence, 239, 243
o
e
contrle de TD, 15
o
contrle des comptences, 15
o
e
courbes fractales, 126
courbes paramtres, 136
e e
addition binaire, 132

achage inverse, 58
algorithme dEuclide, 56
alternative simple et test simple, 70
annuaire tlphonique, 171
ee
application dune fonction, 182
autonomie, 13
damier, 61
dessin dtoiles, 53, 59
e
dessins gomtriques, 74
e e
dessins sur la plage, 13, 22
division chinoise, 24
division enti`re, 56
e
dcodage base b dcimal, 112
e
e
dveloppements limits, 73
e
e
calcul des impts, 73

o
calcul vectoriel, 73
calcul Shadok, 25
caract`res, mots, lignes dune cha 165
e
ne,
catgorie sportive, 51
e
circuits logiques, 47, 67
codage dun nombre fractionnaire, 101
codage des entiers positifs, 100, 113
codage des rels, 133
e
codes ASCII et cha
nes de caract`res, 183
e
coecients du binme, 131
o
comparaison dalgorithmes de recherche, 184
comparaison dalgorithmes de tri, 179, 185
complexit du tri par slection, 175
e
e
complment ` 2, 132
e
a
environnement de travail, 18
excutions dinstructions itratives, 71
e
e
gure gomtrique, 62, 72
e e
fonction dAckerman, 132
fonction factorielle, 54, 62
fonction porte, 49
254
EXERCICES
255
fonction puissance, 131

fonction sinus, 55
prix dune photocopie, 73

puissance de calcul, 21
gnration de squences, 182

e e
e
que fait cette procdure ?, 182

e
intgration numrique, 134

e
e
inverser une cha 164
ne,
racine carre enti`re, 71

e
e
racines du trinome, 70
recherche dun motif, 184
recherche de toutes les occurences, 184
recherche dichotomique, 172
liste ordonne, 174

e
lois de De Morgan, 48
maximum de 2 nombres, 49
multiplication arabe, 23
multiplication ` la russe , 23
a
mthode dlimination de Gauss, 184
e
e
nid dabeilles, 60
nombre de contrles, 16
o
nombres dexercices de TD, 18
oprateurs boolens drivs, 47, 60
e
e
e e
oprations sur les cha
e
nes de caract`res, 164
e
oprations sur les les, 168
e
oprations sur les listes, 165
e
oprations sur les matrices, 170, 183
e
oprations sur les n-uplets, 163
e
oprations sur les piles, 168
e
ouverture dun guichet, 50
parcours inverse, 58
passage par valeur, 116, 130
permutation circulaire, 45, 66
pgcd et ppcm de 2 entiers, 125, 163
police dassurance, 75
porte des variables, 121, 130
e
site Web, 14
spcication et implmentations, 114
e
e
stockage de donnes, 22
e
suite arithmtique, 44, 126
e
suite gomtriques, 131
e e
suites numriques, 73
e
slection dlments, 166
e
ee
squence daectations, 45, 66
e
squences de tests, 70
e
tables de vrit, 74
e e
tours de Hano 123
,
tri bulles, 184
tri dun annuaire, 174
tri par insertion, 176
unit de longueur, 66
e
unit de pression, 42
e
units dinformation, 9
e
valeurs par dfaut, 119
e
zro dune fonction, 75
e
Algorithmes
algorithme dEuclide, 45, 51, 55, 208
palindrome, 215
permutation circulaire, 66
permutation de nombres, 45
polygones rguliers, 22, 28
e
produit de matrices, 216
calcul vectoriel, 73, 84

circuits logiques, 47, 67
codage des rels, 133, 142
e
codage en base b, 72, 82, 100, 210
coecients du binme, 72, 131, 140, 209
o
courbes fractales, 126, 211
courbes paramtres, 136, 147
e e
`
crible dEratosthene, 212
racine carre enti`re, 71, 80

e
e
racines du trinome, 70, 80
recherche dichotomique, 173, 217
recherche squentielle, 171, 217
e
dveloppements limits, 54, 55, 73, 85, 213

e
e
suites numriques, 58, 73, 83, 113, 131, 139

e
fonction dAckerman, 132, 140

fonction factorielle, 54, 214
fonction puissance, 54, 131, 139, 214
tables de multiplication, 52, 59

tables de vrit, 60, 87
e e
tours de Hano 218
,
tri bulles, 219
tri fusion, 219
tri par insertion, 176, 220
tri par slection, 174, 221
e
tri rapide, 179, 221
triangle de Pascal, 82
intgration numrique, 134, 144

e
e
maximum de 2 nombres, 49
nid dabeilles, 60
nombres de Fibonacci, 62, 72, 82, 104113,
215
`
nombres premiers, voir crible dEratosthene
valeur absolue, 49
zro dune fonction, 75, 89
e
oprations binaires, 132, 141

e
256
Liste des gures

1.1
1.2
1.3
1.4
1.5
1.6
1.7
1.8
1.9
1.10
1.11
1.12
1.13
1.14
1.15
1.16
1.17
1.18
1.19
1.20
1.21
1.22
1.23
Dnitions de lAcadmie (1) . .

e
e
John Von Neumann (1903-1957)
Architecture de Von Neumann .
e
e
Du probl`me au code source . . .
e
e
e
Cl USB (Universal Serial Bus) .
e
Du code source ` son excution .
a
e
Taxonomie de Bloom . . . . . . .
Transparent de cours . . . . . . .
Mtaphore de la cible . . . . . .
e
Support de cours . . . . . . . . .
Pentagone, hexagone, octogone .
Tableau dIbn al-Banna . . . . .
Boulier chinois . . . . . . . . . .
R`gles de la division par 7 . . . .
e
Les Shadoks : ga bu zo meu . .
Les 18 premiers nombres Shadok
Spirales rectangulaires . . . . . .
Le premier ordinateur (1946) . .
Premiers micro-ordinateurs . . .
Du 8086 (1978) au Core 2 (2006)
Micro-ordinateurs rcents . . . .
e
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
257
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
5
5
6
7
8
8
9
11
14
15
17
23
24
24
25
26
26
27
31
31
32
32
258
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
2.10
2.11
2.12
2.13
2.14
2.15
2.16
2.17
2.18
2.19
2.20
3.1
3.2
3.3
3.4
3.5
3.6
3.7
3.8
3.9
3.10
3.11
3.12
3.13
ALGORITHMES
Dnition de lacadmie (4) . . . . .
e
e
Mots rservs en Python . . . . . .
e
e
Types de base en Python . . . . . .
e
e
Principales aectations en Python .
Flux dinstructions . . . . . . . . . .
e
e
Le test simple . . . . . . . . . . . . .
Principaux oprateurs Python . . .
e
Lalternative simple . . . . . . . . .
Aiguillage if ... else . . . . .
if ... else imbriqus . . . . .
e
Lalternative multiple . . . . . . . .
e
e
Boucle while . . . . . . . . . . . . .
Euclide . . . . . . . . . . . . . . . .
Boucle for . . . . . . . . . . . . . .
Blocs dinstructions . . . . . . . . .
Nid dabeilles . . . . . . . . . . . . .
Invariant de boucle . . . . . . . . . .
Rutilisabilit dun algorithme . . .
e
e
Encapsulation . . . . . . . . . . . . .
Module math de Python . . . . . .
Mtaphore de la bo de cubes . . .
e
te
Mots rservs en Python . . . . . .
e
e
Param`tres dune fonction . . . . . .
e
Fonction fibonacci (1) . . . . . . .
Robustesse dun algorithme . . . . .
Linstruction assert en Python . .
Dnition de lAcadmie (8) . . . . .
e
e
Le module doctest . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
42
43
43
44
44
46
46
47
47
48
49
49
50
52
52
56
58
59
60
97
100
101
102
103
105
106
107
107
107
108
108
109
112
ALGORITHMES
3.14
3.15
3.16
3.17
3.18
3.19
3.20
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
4.10
4.11
4.12
4.13
4.14
4.15
4.16
4.17
4.18
4.19
4.20
Rcursivit en arbre : fibonacci .

e
e
Tours de Hano (1) . . . . . . . . .
Tours de Hano (2) . . . . . . . . .
Rcursivit en arbre : hanoi . . . .

e
e
Rcursivit linaire : factorielle
e
e e
Courbes paramtres . . . . . . . .
e e
Documentation en Python . . . .
Dnitions de lAcadmie (9) . . .
e
e
Exemple de collection . . . . . . .
Elments dune squence . . . . . .
e
e
Nud dun arbre . . . . . . . . . .
Exemple darbre . . . . . . . . . .
Sommet dun graphe . . . . . . . .
Schma dun graphe orient . . . .
e
e
Exemple de graphe . . . . . . . . .
e
e
e
e
Piles dassiettes . . . . . . . . . . .
Files dattente ` un page . . . . .
a
e
e
e
Echiquier . . . . . . . . . . . . . .
Tri par slection . . . . . . . . . .
e
Tri par insertion . . . . . . . . . .
Partition dune liste . . . . . . . .
Tri rapide . . . . . . . . . . . . . .
Codes des caract`res de contrle .
e
o
Pont de Wheatstone . . . . . . . .
259
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
122
123
123
124
125
137
156
158
160
160
161
161
161
162
162
165
167
167
167
168
168
174
175
177
177
194
200
260
ALGORITHMES
Liste des exemples

1.1
1.2
1.3
1.4
1.5
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
2.10
2.11
2.12
2.13
2.14
2.15
2.16
2.17
2.18
Mode demploi dun tlcopieur . . . . . .

ee
Trouver son chemin . . . . . . . . . . . .
Description de cl USB . . . . . . . . . .
e
Erreur de syntaxe en langage C . . . . . .
Erreur de nom en Python . . . . . . . .
La temprature Fahrenheit . . . . . . . .
e
Permutation de 2 nombres . . . . . . . . .
Un calcul de pgcd (1) . . . . . . . . . . .
Extrait dun dialogue entre un conducteur
Valeur absolue dun nombre . . . . . . . .
Fonction porte . . . . . . . . . . . . .
Etat de leau . . . . . . . . . . . . . . . .
Mentions du baccalaurat . . . . . . . . .
e
Un calcul de pgcd (2) . . . . . . . . . . .
Table de multiplication . . . . . . . . . .
Fonction puissance . . . . . . . . . . . . .
Fonction exponentielle . . . . . . . . . . .
Un calcul de pgcd (3) . . . . . . . . . . .
Achage caract`re par caract`re . . . . .
e
e
Tables de multiplication . . . . . . . . . .
Tables de vrit . . . . . . . . . . . . . . .
e e
Nid dabeilles . . . . . . . . . . . . . . . .
Excution dune boucle . . . . . . . . . .
e
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
gar et un piton
e e
e
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
261
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
5
6
8
12
19
42
45
45
48
49
49
49
51
51
52
54
54
55
58
59
60
60
62
262
2.19
2.20
3.1
3.2
3.3
3.4
3.5
3.6
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
ALGORITHMES
Nombres de Fibonacci . . . . . . . . .
Enfoncer un clou . . . . . . . . . . . .
Numration en base b . . . . . . . . .
e
Nombres fractionnaires . . . . . . . . .
Calcul de sin(/2) . . . . . . . . . . .
Nombres de Fibonacci . . . . . . . . .
Tours de Hano . . . . . . . . . . . . .
Fonction factorielle . . . . . . . . . . .
Distance entre 2 points du plan . . . .
Tas de chaussures . . . . . . . . . . . .
Tableau nal dun tournoi de football
Carte routi`re . . . . . . . . . . . . . .
e
Pile dassiettes . . . . . . . . . . . . .
File dattente de voitures . . . . . . .
Echiquier . . . . . . . . . . . . . . . .
Addition de 2 matrices . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
62
95
100
101
102
104
123
124
158
160
161
162
167
167
168
170
Liste des exercices

1.1
1.2
1.3
1.4
1.5
1.6
1.7
1.8
1.9
1.10
1.11
1.12
1.13
1.14
1.15
1.16
1.17
1.18
1.19
1.20
1.21
1.22
1.23
Dessins sur la plage : excution (1) . . . .

e
Dessins sur la plage : conception (1) . . .
Proprits dun algorithme . . . . . . . .
ee
Units dinformation . . . . . . . . . . . .
e
Premi`re utilisation de Python . . . . .
e
Erreur de syntaxe en Python . . . . . .
Dessins sur la plage : persvrance . . . .
e e
Autonomie . . . . . . . . . . . . . . . . .
Site Web dInformatique S1 . . . . . . . .
Exemple de contrle dattention (1) . . .
o
Exemple de contrle de TD . . . . . . . .
o
Exemple de contrle dautoformation (1) .
o
Exemple de contrle des comptences . .
o
e
Nombre de contrles . . . . . . . . . . . .
o
Exemple de contrle dautoformation (2) .
o
Exemple de contrle dattention (2) . . .
o
Nombres dexercices de TD . . . . . . . .
Environnement de travail . . . . . . . . .
QCM (1) . . . . . . . . . . . . . . . . . .
Puissance de calcul . . . . . . . . . . . . .
Stockage de donnes . . . . . . . . . . . .
e
Dessins sur la plage : excution (2) . . . .
e
Dessins sur la plage : conception (2) . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
263
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6
6
7
9
11
13
13
13
14
14
15
15
15
16
17
17
18
18
20
21
22
22
22
264
1.24
1.25
1.26
1.27
1.28
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
2.10
2.11
2.12
2.13
2.14
2.15
2.16
2.17
2.18
2.19
2.20
2.21
2.22
2.23
2.24
2.25
2.26
2.27
2.28
ALGORITHMES
Tracs de polygones rguliers .
e
e
La multiplication ` la russe
a
La multiplication arabe . . . .
La division chinoise . . . . . . .
Le calcul Shadok . . . . . . . .
Unit de pression . . . . . . . .
e
Suite arithmtique (1) . . . . .
e
Permutation circulaire (1) . . .
Squence daectations (1) . .
e
Oprateurs boolens drivs (1)
e
e
e e
Circuit logique (1) . . . . . . .
Lois de De Morgan . . . . . . .
Maximum de 2 nombres . . . .
Fonction porte . . . . . . .
Ouverture dun guichet . . . .
Catgorie sportive . . . . . . .
e
Dessin dtoiles (1) . . . . . . .
e
Fonction factorielle . . . . . . .
Fonction sinus . . . . . . . . .
Algorithme dEuclide . . . . . .
Division enti`re . . . . . . . . .
e
Achage inverse . . . . . . . .
Parcours inverse . . . . . . . .
Suite arithmtique (2) . . . . .
e
Dessin dtoiles (2) . . . . . . .
e
Oprateurs boolens drivs (2)
e
e
e e
Damier . . . . . . . . . . . . .
Trace de la fonction factorielle
Figure gomtrique . . . . . . .
e e
QCM (2) . . . . . . . . . . . .
Unit de longueur . . . . . . .
e
Permutation circulaire (2) . . .
Squence daectations (2) . .
e
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
22
23
23
24
25
42
44
45
45
47
47
48
49
49
50
51
53
54
55
56
56
58
58
58
59
60
61
62
62
63
66
66
66
ALGORITHMES
2.29
2.30
2.31
2.32
2.33
2.34
2.35
2.36
2.37
2.38
2.39
2.40
2.41
2.42
2.43
2.44
2.45
3.1
3.2
3.3
3.4
3.5
3.6
3.7
3.8
3.9
3.10
3.11
3.12
3.13
3.14
3.15
3.16
Circuits logiques (2) . . . . . . . . . .

Alternative simple et test simple . . .
Racines du trinome . . . . . . . . . . .
Squences de tests . . . . . . . . . . .
e
Racine carre enti`re . . . . . . . . . .
e
e
Excutions dinstructions itratives . .
e
e
Figures gomtriques . . . . . . . . . .
e e
Suites numriques . . . . . . . . . . .
e
Calcul vectoriel . . . . . . . . . . . . .
Prix dune photocopie . . . . . . . . .
Calcul des impts . . . . . . . . . . . .
o
Dveloppements limits . . . . . . . .
e
e
Tables de vrit . . . . . . . . . . . . .
e e
Dessins gomtriques . . . . . . . . . .
e e
Police dassurance . . . . . . . . . . .
Zro dune fonction . . . . . . . . . . .
e
Suite arithmtique (3) . . . . . . . . .
e
Codage des entiers positifs (1) . . . . .
Codage dun nombre fractionnaire . .
Dcodage base b dcimal . . . . . .
e
e
Codage des entiers positifs (2) . . . . .
Une spcication, des implmentations
e
e
Passage par valeur . . . . . . . . . . .
Valeurs par dfaut . . . . . . . . . . .
e
Porte des variables . . . . . . . . . .
e
Tours de Hano ` la main . . . . . . .
a
Pgcd et ppcm de 2 entiers (1) . . . . .
Somme arithmtique . . . . . . . . . .
e
Courbes fractales . . . . . . . . . . . .
QCM (3) . . . . . . . . . . . . . . . .
Passage des param`tres . . . . . . . .
e
Porte des variables (2) . . . . . . . .
e
Suite gomtrique . . . . . . . . . . .
e e
265
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
67
70
70
70
71
71
72
73
73
73
73
73
74
74
75
75
97
100
101
112
113
114
116
119
121
123
125
126
126
128
130
130
131
266
3.17
3.18
3.19
3.20
3.21
3.22
3.23
3.24
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
4.10
4.11
4.12
4.13
4.14
4.15
4.16
4.17
4.18
4.19
4.20
4.21
4.22
4.23
4.24
4.25
ALGORITHMES
Puissance enti`re . . . . . . . . . . . . . . . . . . . . . . .
e
Coecients du binme . . . . . . . . . . . . . . . . . . . .
o
Fonction dAckerman . . . . . . . . . . . . . . . . . . . . .
Addition binaire . . . . . . . . . . . . . . . . . . . . . . .
Complment ` 2 . . . . . . . . . . . . . . . . . . . . . . .
e
a
Codage-dcodage des rels . . . . . . . . . . . . . . . . . .
e
e
Intgration numrique . . . . . . . . . . . . . . . . . . . .
e
e
Tracs de courbes paramtres . . . . . . . . . . . . . . .
e
e e
Distance de 2 points de lespace . . . . . . . . . . . . . . .
Oprations sur les n-uplets . . . . . . . . . . . . . . . . .
e
Pgcd et ppcm de 2 entiers (2) . . . . . . . . . . . . . . . .
Oprations sur les cha
e
nes . . . . . . . . . . . . . . . . . .
Inverser une cha . . . . . . . . . . . . . . . . . . . . . .
ne
Caract`res, mots, lignes dune cha . . . . . . . . . . . .
e
ne
Oprations sur les listes (1) . . . . . . . . . . . . . . . . .
e
Oprations sur les listes (2) . . . . . . . . . . . . . . . . .
e
Slection dlments . . . . . . . . . . . . . . . . . . . . .
e
ee
Oprations sur les piles . . . . . . . . . . . . . . . . . . .
e
Oprations sur les les . . . . . . . . . . . . . . . . . . . .
e
Produit de matrices . . . . . . . . . . . . . . . . . . . . .
Annuaire tlphonique . . . . . . . . . . . . . . . . . . . .
ee
Recherche dichotomique . . . . . . . . . . . . . . . . . . .
Liste ordonne . . . . . . . . . . . . . . . . . . . . . . . .
e
Tri dun annuaire tlphonique . . . . . . . . . . . . . . .
ee
Complexit du tri par slection . . . . . . . . . . . . . . .
e
e
Tri par insertion . . . . . . . . . . . . . . . . . . . . . . .
Comparaison dalgorithmes (1) . . . . . . . . . . . . . . .
QCM (4) . . . . . . . . . . . . . . . . . . . . . . . . . . .
Gnration de squences . . . . . . . . . . . . . . . . . . .
e e
e
Application dune fonction ` tous les lments dune liste
a
ee
Que fait cette procdure ? . . . . . . . . . . . . . . . . . .
e
Codes ASCII et cha
nes de caract`res . . . . . . . . . . .
e
Oprations sur les matrices . . . . . . . . . . . . . . . . .
e
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
131
131
132
132
132
133
134
136
158
163
163
164
164
165
165
166
166
168
168
170
171
172
174
174
175
176
179
180
182
182
182
183
183
ALGORITHMES
4.26
4.27
4.28
4.29
4.30
4.31
Recherche dun motif . . . . . . . . . . . .

Recherche de toutes les occurences . . . .
Tri bulles . . . . . . . . . . . . . . . . . .
Mthode dlimination de Gauss . . . . .
e
e
Comparaison dalgorithmes de recherche.
Comparaison dalgorithmes de tri . . . . .
267
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
184
184
184
184
184
185
268
ALGORITHMES
Rfrences
ee
[1] Harold Abelson, Gerald Jay Sussman, and Julie Sussman. Structure et interprtation des
e
programmes informatiques. InterEditions, 1989.
Autre approche de lalgorithmique fonde sur la programmation fonctionnelle.
e
cit page 2.
e
[2] Jean-Luc Chabert, Evelyne Barbin, Michel Guillemot, Anne Michel-Pajus, Jacques Borowczyk, Ahmed Djebbar, and Jean-Claude Martzlo. Histoire dalgorithmes : du caillou ` la
a
puce. Belin, 1994.
Regard historique sur quelques algorithmes dont celui de la multiplication arabe.
cit page 23.
e
[3] Henri-Pierre Charles. Initiation ` linformatique. Eyrolles, 2000.

a
Petit livre dintroduction ` lalgorithmique.
a
cit page 11.
e
[4] Karine Chemla and Guo Shuchun. Les neuf chapitres : le classique mathmatique de la
e
Chine ancienne et ses commentaires. Dunod, 2004.
`
Traduction franaise dun texte chinois vieux de 2000 ans : Jiuzhang suanshu , dont le 8eme chapitre,
c
sous le titre Fang cheng (la disposition rectangulaire) dcrit la mthode dlimination de Gauss .
e
e
e
cit page 204.
e
[5] Christophe Darmangeat. Algorithmique et programmation pour non-matheux. Universit

e
Paris 7, www.pise.info/algo.
Cours en ligne dinitiation ` lalgorithmique.
a
cit pages 18,61.
e
[6] Jean-Paul Delahaye. Complexits : aux limites des mathmatiques et de linformatique.

e
e
Belin, 2006.
269

REFERENCES
270
Ouvrage de vulgarisation sur la complexit.
e
cit page 21.
e
[7] Fernand Didier. Elaboration dalgorithmes itratifs

e
, iml.univ-mrs.fr/~lafont/licence/prog2.pdf.
Petit polycopi qui introduit simplement la notion dinvariant de boucle.
e
cit page 95.
e
[8] Pierre Florent, Michelle Lauton, and Grard Lauton. Outils et mod`les mathmatiques,
e
e
e
volume 3. Vuibert, 1977.
Ouvrage dintroduction ` lalg`bre linaire dont le chapitre 4 traite de la rsolution numrique des syst`mes
a
e
e
e
e
e
algbriques linaires non homog`nes.
e
e
e
cit pages 169,200.
e
[9] Christine Froidevaux, Marie-Christine Gaudel, and Mich`le Soria. Types de donnes et
e
e
algorithmes. McGraw-Hill, 1990.
Bonne introduction aux types abstraits de donnes et ` la complexit des algorithmes.
e
a
e
cit pages 172,173.
e
[10] Richard Gruet. Python 2.5 quick reference, rgruet.free.fr/#QuickRef, 2007.

Rfrence bien pratique quil faut avoir avec soi quand on programme en Python.
ee
cit pages 41,57,92,153,155,194,198.
e
[11] Marc Guyomard. Spcication et programmation : le cas de la construction de boucles,

e
www.irisa.fr/cordial/mguyomar/poly-init-06-07.ps, 2005.
Polycopi de cours qui aborde en dtail la construction des boucles ` partir de la notion dinvariant.
e
e
a
cit page 95.
e
[12] Donald Ervin Knuth. The art of computer programming, volume 1-Fundamental algorithms,
2-Seminumerical Algorithms, 3-Searching and sorting. Addison-Wesley, 1997.
La rfrence en algorithmique. Deux autres volumes sont en prparation : 4-Combinatorial Algorithms et
ee
e
5-Syntactic Algorithms. Pour la petite histoire, D.E. Knuth est galement lauteur de TEX (prononcer tech
e
comme dans technologie), syst`me logiciel de composition de documents utilis pour gnrer le document
e
e
e e
que vous tes en train de lire cr ` partir de 1977 pour rpondre ` la mauvaise qualit typographique
e
ee a
e
a
e
de la deuxi`me dition de The art of computer programming.
e
e
cit pages 172,173.
e
[13] Zohar Manna and Richard Waldinger. The logical basis for computer programming, volume
1 : Deductive reasoning. Addison-Wesley, 1985.

REFERENCES
271
Ouvrage sur les types abstraits de donnes prsents ` laide dun formalisme logique rigoureux.
e
e
e a
cit pages 159, 193.
e
[14] Jean-Jacques Rousseau. Physique et simulations numriques. Universit du Maine,

e
e
site : www.univ-lemans.fr/enseignements/physique/02/, 2007.
Site pdagogique prsentant plus de 300 simulations numriques de petits travaux pratiques de physique.
e
e
e
cit page 200.
e
[15] Jacques Rouxel. Les Shadoks : ga bu zo meu. Circonexe, 2000.

Quand les Shadoks comptaient en base 4. . . BD issue dune cl`bre srie tlvise danimation franaise en
ee
e
ee e
c
208 pisodes de 2 ` 3 minutes, diuse entre 1968 et 1973 (trois premi`res saisons) et ` partir de janvier
e
a
e
e
a
2000 (quatri`me saison).
e
cit page 25.
e
[16] Grard Swinnen. Apprendre ` programmer avec Python. OReilly, 2005.

e
a
Manuel dinitiation ` la programmation bas sur Python. Ce manuel existe dornavant sous deux formes :
a
e
e
un ouvrage imprim publi par les ditions OReilly et un chier PDF ou SXW librement tlchargeable sur
e
e
e
ee
www.cifen.ulg.ac.be/inforef/swi/python.htm
cit page 10.
e

Langue

Bienvenue sur Scribd !

Initiation

Transféré par

Informations du document

Date du transfert

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Description :

Droits d'auteur :

Formats disponibles

Initiation

Transféré par

Description :

Droits d'auteur :

Formats disponibles

Titres liés

Cours dInformatique S1

Centre Europeen de Realite Virtuelle

version du 01 septembre 2009

Avec la participation de Romain Benard, Stephane

Bonneaud, Cedric Buche, Gireg Desmeulles, Eric

Maisel, Alexis Nedelec, Marc Parenthoen et Cyril Septseault.

Liste des gures

Liste des exemples

Liste des exercices

Chaque programme dordinateur est un mod`le, forg par lesprit, dun

Ecole Nationale dIngenieurs de Brest

Fig. 1.1 : Definitions de lAcademie (1)

MATERIEL adj. et n. XIIIe si`cle. Emprunt du

r`gle, met en ordre ; ordonnateur . Equipement ine

Dnition 1.2 : materiel

1.1. CONTEXTE SCIENTIFIQUE

Fig. 1.2 : John Von Neumann (1903-1957)

1. Lunit arithmtique et logique, ou unit de traitement, eectue les oprations de base.

Fig. 1.3 : Architecture de Von Neumann

1. Insrez le document dans le chargeur automatique.

TD 1.1 : Dessins sur la plage : execution (1)

Fig. 1.4 : Definitions de lAcademie (2)

DONNEE n. f. XIIIe si`cle, au sens de distrie

Dnition 1.6 : validite dun algorithme

1.1. CONTEXTE SCIENTIFIQUE

Si lon reprend lexemple 1.2 de lalgorithme de recherche du chemin de la gare, ltude de sa

Dnition 1.8 : reutilisabilite dun algorithme

Dnition 1.9 : complexite dun algorithme

Si le touriste gar est un piton, la complexit de lalgorithme de recherche de chemin peut

Dnition 1.10 : efficacite dun algorithme

Fig. 1.6 : Definitions de lAcademie (3)

Un algorithme exprime la structure logique dun programme informatique et de ce fait est

Fig. 1.7 : Cle USB (Universal Serial Bus)

Dispositif matriel cone

Exemple 1.3 : Description de cle USB

1.1. CONTEXTE SCIENTIFIQUE

puissance enti`re de 2 immdiatement suprieure (220 = 1 048 576) pour dnir le Mo : 1 Mo =

TD 1.4 : Unites dinformation

Dnition 1.13 : compilateur

Dnition 1.14 : interpreteur

Fig. 1.8 : Du code source a son execution

ADA, C/C++, Fortran

Compilation : La compilation consiste ` traduire la totalit du code source en une fois. Le

1.2. OBJECTIFS DU COURS

Fig. 1.9 : Taxonomie de Bloom

: dnir, distinguer, acqurir, identier,

Remarque 1.1 : Lannexe A page 207 prsente quele

Nous cherchons ` dvelopper trois qualits comportementales chez linformaticien dbua e

1.3. ORGANISATION DU COURS

Mme si un humain peut transiger sur le ; , la machine ne le peut pas : lordinateur ne

Les enseignements dinformatique S1 de lENIB sont dispenss lors de 42h de sances de

TD 1.6 : Erreur de syntaxe en Python

Remarque 1.2 : Un semestre stale sur 14 semaines

Fig. 1.10 : Transparent de cours

(P. Dreyfus, 1962)

informatique : science du traitement automatique de

1. les instructions de base (chapitre 2 page 39),

(J. Perret, 1955)