Informatique Pour Tous: Scientifiques

CPGE
scientifiques Nicolas Nguyen

Gweltaz Chatel
P R É P A S S C I E N C E S
COLLECTION DIRIGÉE PAR BERTR AND HAUCHECORNE
IPT
INFORMATIQUE
POUR TOUS
Algorithmique, programmation Python,
ingénierie numérique et simulation
(bibliothèques Numpy et Scipy de Python)
Les 2 années
en 1 clin d’œil
PRÉPAS
SCIENCES
collection dirigée par Bertrand Hauchecorne
IPT
Informatique
pour tous
Algorithmique, programmation Python,
ingénierie numérique et simulation
(bibliothèques Numpy et Scipy de Python)
Nicolas NGUYEN
Professeur au lycée F. Rabelais (Saint-Brieuc)
Gweltaz CHATEL
Professeur au lycée F. Rabelais (Saint-Brieuc)
COLLECTION
PRÉPAS SCIENCES
Retrouvez tous les titres de la collection

et des extraits sur www.editions-ellipses.fr
ISBN 9782340-026346
© Ellipses Édition Marketing S.A., 2018
32, rue Bargue 75740 Paris cedex 15
"WBOUQSPQPT
La réussite en prépa nécessite une acquisition solide des connais-

sances et une capacité à les mettre en réseau ; elle exige par ailleurs
d’en avoir une vision claire et de savoir les mobiliser rapidement.
Si les ouvrages de la collection Prépas Sciences répondent au pre-
mier besoin, ce formulaire d’Informatique Pour Tous (IPT) vous
permettra de satisfaire à la deuxième exigence. Il présente en effet
de manière claire et concise tous les thèmes et compétences du pro-
gramme d’IPT des classes préparatoires aux grandes écoles scienti-
fiques et permet de visualiser en un clin d’oeil :
• La base de connaissances théoriques
• Les algorithmes et programmes à connaître
• Les compétences indispensables.
Ces thèmes sont traités en 20 chapitres (10 de première année et 10

de deuxième année), tous organisés de la manière suivante :
• Description du thème scientifique et de la méthode numérique
• Algorithme et preuve de l’algorithme
• Implémentation en P YTHON.
Enfin, une boîte à outils mentionnant les fonctions P YTHON, natives
ou issues de ses bibliothèques complètent utilement chaque chapitre.
En fin d’ouvrage, deux index très précis (un index général et un index
des commandes) permettent de trouver rapidement et sans hésitation
la notion cherchée.
Ainsi, ce formulaire sera le compagnon idéal pour réviser avant les
concours, mais également comme ressource au quotidien pour pré-
parer les séances de Travaux Pratiques d’informatique et de TIPE.
Nicolas NGUYEN
III
BB
I BASE DE CONNAISSANCE 1
1 Types d’objets en Python Sommaire
Nombres, listes, t-uplets, chaînes de caractères, ensembles k
2
Variables . . . . . . . . . . . . . . . . . . . . . . . . . . d
Listes en Python . . . . . . . . . . . . . . . . . . . . . . Ry
2 Programmation Partie en Python

1. Base de connaissance 13
Structures séquentielles, conditionnelles, itératives . . . . Rj
Fonctions et modules . . . . . . . . . . . . . . . . . . . Rd
1. TypesSpécification,
d’objets en Python ......................................................................2
terminaison, correction, complexité . . . . kj
Nombres, listes, t-uplets, chaînes de caractères, ensembles .................. 2
3 Variables
Python pour l’ingénierie numérique et la simulation 27
.................................................................................................7
Tableaux avec Numpy . . . . . . . . . . . . . . . . . . .
Listes en Python ....................................................................................kd10
Outils pour l’ingénierie numérique, la simulation . . . . . jR
2. Programmation en Python .................................................................13
4 Structures
Bases de séquentielles,
données et algèbre conditionnelles,
relationnelleitératives ............................35 13
Fonctions
Algèbre relationnelle . . . . . . . . . . . . . . . . . . . . j817
et modules ............................................................................
Commandes
Spécification, SQL . correction,
terminaison, . . . . . . complexité
. . . . . . ...............................
. . . . . . . je 23
3. Python pour l’ingénierie numérique et la simulation .....................27
Tableaux avec Numpy ........................................................................... 27
II Outils
ALGORITHMES DE PREMIÈRE
pour l’ingénierie numérique et la simulation ANNÉE 3931
.............................
4.1 Bases
Programmer avec
de données et les réelsrelationnelle .........................................35
algèbre 40
Sommes et produits finis . . . . . . . . . . . . . . . . .
Algèbre relationnelle .............................................................................9y35
Puissances
Commandes SQLd’un réel . . . . . . . . . . . . . . . . . . . . 9j
.................................................................................. 36
Évaluation polynomiale . . . . . . . . . . . . . . . . . . 9d
2 Programmer avec les entiers 51

Partieeuclidienne
Division 2. Algorithmes . . . . .de . .première
. . . . . . année . . . . . . . 8R
Test de primalité simple . . . . . . . . . . . . . . . . . . 8j
Décomposition
1. Programmer avec lesprimaire d’un entier . . . . . . . . . . . . 89
réels ................................................................ 40
Sommes et produits finis ......................................................................40
Puissances d’un réel .............................................................................. 43
BBB
Évaluation polynomiale ........................................................................ 47
2. Programmer avec les entiers ..............................................................51
Division euclidienne ............................................................................. 51
Test de primalité simple ........................................................................ 53
Décomposition primaire d’un entier ..................................................... 54
Calcul du PGCD de deux entiers .......................................................... 57
Conversion d’un entier naturel en base b ............................................. 59
Conversion de la base b vers la base 10 ................................................ 62
V
Résolution d’un système triangulaire . . . . . . . . . . . Rkk
3. Recherche d’élément dans uneBp liste ...................................................65

Présence d’un élément dans une liste ................................................... 65
Recherche dichotomique d’un élément ................................................. 67
Première occurrence d’un élément ....................................................... 69
Nombre d’occurrences d’un élément .................................................... 71
4. Statistiques sur une liste de réels .......................................................73
Maximum d’une liste ............................................................................ 73
Moyenne d’une liste .............................................................................. 75
Variance d’une liste .............................................................................. 77
Médiane d’une liste ............................................................................... 79
5. Recherche d’une sous-séquence ........................................................ 83
Recherche d’une séquence dans une liste ............................................. 83
Présence d’un mot dans une chaîne ...................................................... 85
6. Programmer avec les suites et les fonctions .................................... 88
Suite récurrente un + 1 = f (un) ............................................................... 88
Suite récurrente un + 2 = f (un + 1 ; un) ...................................................... 89
Valeur maximale d’une fonction ........................................................... 91
7. Résolution numérique des équations non linéaires .........................94
Recherche d’un zéro par dichotomie ....................................................94
Méthode du point fixe ........................................................................... 97
Méthode de Newton ............................................................................ 100
Méthode de Lagrange ......................................................................... 103
8. Intégration numérique .....................................................................106
Méthode des rectangles ...................................................................... 106
Méthode des trapèzes .......................................................................... 108
9. Résolution numérique des équations différentielles ......................112
Équation différentielle scalaire ........................................................... 112
Équation différentielle vectorielle .......................................................114
Équation différentielle d’ordre supérieur ........................................... 118
10. Résolution numérique d’un système linéaire .................................121
Résolution d’un système triangulaire ................................................. 122
Opérations élémentaires sur les lignes d’un système
ou d’une matrice ................................................................................. 125
Résolution d’un système par la méthode de Gauss ............................ 127
VI
17 Gauss-Legendre 202
p
Partie 3. Algorithmes de deuxième année
11. Algorithmes de tri .............................................................................134

Tri par insertion .................................................................................. 134
Tri rapide ............................................................................................. 136
Recherche rapide de la médiane ......................................................... 141
Tri Fusion ............................................................................................ 144
Autres tris ............................................................................................ 148
Comparatifs des différents tris ........................................................... 154
12. Traitement numérique des images ..................................................155
Représentation des images .................................................................. 155
Premières manipulations .................................................................... 156
Recherche naïve de contours .............................................................. 157
Traitement par convolution ................................................................. 158
13. Codage et transmission .....................................................................161
Algorithmes de cryptage élémentaires ............................................... 161
Sommes de contrôle, codes correcteurs ............................................. 163
14. Graphes ..............................................................................................167
Représentation d’un graphe ................................................................ 167
Algorithme de plus court chemin ....................................................... 169
Le problème du voyageur de commerce ............................................. 175
Tri par tas ............................................................................................ 185
15. Arithmétique .....................................................................................190
Le crible d’Erathostène ....................................................................... 190
Calcul de la fonction φ de Euler ......................................................... 192
Algorithme d’Euclide étendu .............................................................. 194
Chiffrement RSA ................................................................................ 195
16. Autour des polynômes ......................................................................197
Représentation et manipulation de polynômes ................................... 197
Division euclidienne ........................................................................... 198
L’algorithme pour les polynômes ........................................................ 199
17. Gauss-Legendre ................................................................................202
Polynômes de Legendre ...................................................................... 202
Méthode d’intégration numérique ......................................................204
VII
18. Probabilités ....................................................................................... 207
Simulation des lois classiques ............................................................. 207
Comparaison des lois binomiale et de Poisson ................................... 210
Illustration de la loi faible des grands nombres .................................. 212
19. Calculs matriciels ..............................................................................215
Quelques opérations de base sur les matrices .................................... 215
Valeur propre de plus grand module ................................................... 216
Exponentielle de matrice .................................................................... 218
20. Piles ....................................................................................................221
Création de la classe Pile .................................................................... 221
Quelques fonctions utilisant les piles ................................................. 223
Index
Index des commandes ......................................................................... 226

pB
Index général ....................................................................................... 228
VIII
1SFNJÒSF QBSUJF
#"4& %& $0//"*44"/$&
Partie 1
Base de connaissance
Ordinateur
Le mot ordinator existait déjà en latin. Chez les Romains,
il désignait celui qui met en ordre, qui règle ou qui préside à
la remise en ordre. Les premiers Chrétiens l’utilisaient pour
nommer celui qui dirige les cérémonies : c’est pourquoi on
LE SAVIEZ-VOUS ?
parle encore de l’ordination des prêtres.

Francisé en ordinateur, il apparaît en français, dans le même
sens, vers 1600 mais reste très peu employé. En 1955, la société
R
IBM s’adresse à un latiniste, Jacques Perret, pour trouver un
nom à ce que les Anglais appellent un computer, mot construit
sur le latin computare qui signifie calculer. Celui-ci propose
le terme d’ordinateur qui s’est désormais imposé dans notre
langue.
On peut s’en réjouir, moins par le souci d’utiliser un mot
français, que pour donner un sens plus large à la terminologie.
En effet, le rôle de l’ordinateur dépasse largement celui du
calculateur puisqu’il met en ordre et gère de multiples activités.
5ZQFT EhPCKFUT FO 1ZUIPO
/PNCSFT MJTUFT UVQMFUT DIBÔOFT EF DBSBDUÒSFT

FOTFNCMFT
Tous les objets que manipule P YTHON ont un type défini à la fois
par l’espace mémoire utilisé pour le stocker mais également par les
règles de représentation, d’opération ou encore de construction qui
s’y appliquent.
-FT EJGGÏSFOUT UZQFT
On peut distinguer deux types d’objets, les simples et les composés.
Types simples
Il s’agit essentiellement de types numériques.
bool un booléen peut être h`m2 ou 6Hb2

int un entier relatif est exact en machine
float un flottant est une valeur approchée d’un réel
complex un complexe est de la forme a+jb
Types composés
Comme leur nom l’indiquent, ces objets sont des collections d’objets
simples.
• On peut déterminer si un objet simple appartient ou non à un
objet composé au moyen de la relation « a in A » qui renvoie un
booléen. Ces objets composés des itérables.
k
2
• Lorsque ces objets composés sont ordonnés, on peut accéder di-
rectement à leurs composants à l’aide de « (F) » qui renvoie l’élé-
ment de rang k. Ils sont alors dits indexables.
• Finalement, si on peut directement modifier les objets simples qui
les composent, on dit qu’ils sont mutables.
Le tableau ci-dessous donne les types composés les plus fréquem-
ment utilisés.
list une liste est un objet mutable, indexable, itérable
tuple un t-uplet est non mutable, indexable, itérable
une chaîne de caractères est non mutable, indexable,
str
itérable
un ensemble est non mutable, non indexable mais
set
itérable
-FT UZQFT TJNQMFT
Les tableaux ci-dessous résument les différents opérateurs sur les ob-
jets simples : opérations arithmétiques, comparaisons, constructions
ou conversions.
Opérations
a+b somme des deux nombres (int,float,complex)

a-b différence des deux nombres (int,float,complex)
a*b produit des deux nombres (int,float,complex)
a/b quotient de deux flottants
a//b quotient de la division euclidienne d’entiers
a%b reste de la division euclidienne d’entiers
divmod(a,b) quotient et reste de la division euclidienne
a**b
a élevé à la puissance b
pow(a,b)
abs(a) valeur absolue ou module de a
j
3
Comparaisons et opérations logiques
a==b test d’égalité, renvoie un booléen

a !=b test de différence, renvoie un booléen
a>b, a<b,
tous ces tests de comparaison, respectivement a > b,
a>=b,
a < b, a b, a b renvoient un booléen
a<=b
P and Q conjonction de deux booléens
P or Q disjonction de deux booléens
not P négation d’un booléen
Conversions
int(a) convertit en entier un flottant ou une chaîne

float(a) convertit en flottant un entier ou une chaîne
complex(a,b) convertit en complexe un couple de flottants
donne la valeur de l’entier donné par son écriture +`
int(car,b)
(de type chaîne) en base #
bin(a) renvoie l’écriture en binaire de l’entier a
oct(a) renvoie l’écriture en octal de l’entier a
hex(a) renvoie l’écriture en hexadecimal de l’entier a
-FT UZQFT DPNQPTÏT
Définitions
• Une liste est une suite d’éléments quelconques (pas nécessaire-

ment de même type) séparés par des virgules et encadrée par des
crochets. Par exemple (- #- +) est une liste. Les listes sont itérables,
indexables et mutables.
• Un t-uplet est une suite d’éléments quelconques (et pas nécessai-
rement de même type) séparés par des virgules et encadrée par des
9
4
parenthèses (ou rien). Par exemple U- #- +V et /- 2- 7 sont des t-uplets.
Les t-uplets sont itérables, indexables mais non mutables.
• Un ensemble est une collection d’objets séparés par des virgules
et encadrée par des accolades. Ainsi, &- #- +' est un ensemble.
Dans un ensemble, ni l’ordre, ni les répétitions éventuelles des élé-
ments ne changent l’ensemble. Les ensembles sont itérables mais
non indexables et non mutables.
• Une chaîne de caractère est une suite de caractères quelconques
encadrée par une paire de simples ou de doubles guillemets. Par
exemple, Ǵ # +Ǵ et Ƕ/ 2 7Ƕ sont des chaînes de caractères. Comme les
listes, les chaînes de caractères sont itérables, indexables mais non
mutables.
Les objets séquentiels que sont les listes, les t-uplets et les chaînes,
sont toujours indexés à partir de 0. (y) désigne le premier élément
de la séquence, (R) le deuxième, etc.
Opérations
retourne la longueur de (liste, t-uplet, chaîne,

len(A)
ensemble)
accède à l’élément d’indice F de la séquence (liste,
A[k]
t-uplet, chaîne)
opération de concaténation, juxtapose les deux

A+B
séquences (liste,t-uplet,chaîne)
opération de duplication, juxtapose M (entier) fois la
n*A
séquence (liste,t-uplet,chaîne)
retourne l’objet maximal de la collection (liste,
max(A)
t-uplet, chaîne, ensemble)
retourne l’objet minimal de la collection (liste,
min(A)
retourne la somme des éléments d’une collection
sum(A)
de nombres (liste, t-uplet, chaîne, ensemble)
8
5
Comparaisons entre objets
teste l’appartenance d’un objet à (liste, t-uplet,

a in A
chaîne, ensemble) et retourne un booléen
teste la non appartenance d’un objet à (liste,
a not in A
t-uplet, chaîne, ensemble) et retourne un booléen
teste l’égalité de et " (listes, t-uplets, chaînes,
A==B
ensembles), retourne un booléen
teste la non égalité de et " (listes, t-uplets, chaînes,
A != B
ensembles), retourne un booléen
test d’inégalité dans l’ordre lexicographique, lorsque
A < B et " sont des séquences (liste, t-uplet, chaîne),
retourne un booléen
test d’inclusion lorsque et " sont des ensembles,
A < B
retourne un booléen
Constructions et conversions
[a,b,c] crée la liste d’objets - #- +

[] ou list() crée la liste vide
(a,b,c) crée le t-uplet d’objets - #- +
a,b,c crée l’ensemble d’éléments - #- +
set() crée l’ensemble vide
"abc"
crée la chaîne de caractères - #- +
ou ’abc’
"" ou ” ou
crée la chaîne de caractères vide
str()
convertit en liste tout type d’objet composé (liste,
list(A)
convertit en ensemble. Élimine les répétitions et
set(A)
range les éléments par ordre croissant, si possible
convertit en chaîne de caractères tout type d’objet
str(A)
composé (liste, t-uplet, chaîne, ensemble)
e
6
7BSJBCMFT
/PUJPO EF WBSJBCMF FO 1ZUIPO
Pour mémoriser une valeur, on la stocke en mémoire. On représente

l’adresse mémoire à l’aide d’un identificateur (chaîne de caractères).
Le couple (identificateur, valeur) est appelé une variable.
Comme nom de la variable, on peut utiliser toute chaîne de caractères
alphanumériques (qui ne commence pas par un chiffre) à l’exception
de quelques mots réservés.
P YTHON distingue les majuscules des minuscules. Ainsi, les chaînes
’Aa’ et ’aa’ sont deux identificateurs différents.
Une variable peut contenir des données de n’importe quel type déjà
présenté. En P YTHON, il n’est pas nécessaire de préciser le type de
valeur que l’on va placer dans une variable. En fait, le type est déter-
miné seulement au moment de l’évaluation, c’est ce que l’on appelle
un typage dynamique.
"GGFDUBUJPO EhVOF WBMFVS Ë VOF WBSJBCMF
Déclaration d’une variable
Avant d’utiliser une variable , il faut toujours lui donner une valeur
initiale. Pour attribuer une valeur à une variable, on utlise l’opérateur
d’affectation, noté « 4 » en P YTHON.
>>> a = 10
Affectation d’une variable
Pour modifier la valeur d’une variable, on utilise l’opérateur d’affec-

tation. On ne confondra pas cet opérateur avec une égalité mathé-
matique. En effet, l’opérateur d’affectation est non symétrique, non
transitif.
d7
>>> x = 1
>>> x = x + a
Dans une affectation, on commence d’abord par évaluer l’expression

de droite, puis on affecte cette valeur à la variable de gauche.
Affectations simultanées
P YTHON permet de réaliser, des affectations simultanées de plu-

sieurs variables, de même type ou non :
>>> x , y , z = ’ abc ’ , 6 , [ ]
En particulier, il est aisé d’échanger le contenu de plusieurs variables

en P YTHON :
>>> x , y , z = y , z , x
0QÏSBUJPOT TVS MFT WBSJBCMFT
Comme une variable représente un objet d’un certain type, tous les
opérateurs rencontrés (opérations, comparaisons, constructions ou
conversions) s’appliquent également aux variables de ce même type.
On appelle expression toute opération composée qui met en jeu va-
riables et constantes. Lorsque les composants sont de même type et
les opérations bien définies, l’expression finale garde le même type.
Lorsque les constantes et les variables sont de types hétérogènes,
l’expression prend le type minimal dans lequel toutes les opérations
sont compatibles.
Opérateurs avec assignation
Il est très fréquent d’avoir à incrémenter une variable, c’est-à-dire à

augmenter sa valeur de 1. P YTHON permet de raccourcir l’instruction
t 4 t Y R en t Y4 R. On dit que Y4 est un opérateur avec
assignation.
3
8
x += y équivaut à l’affectation t 4 t Y v
x -= y équivaut à l’affectation t 4 t @ v
x *= y équivaut à l’affectation t 4 t v
x **=y équivaut à l’affectation t 4 t v
x /= y équivaut à l’affectation t 4 t f v
x //= y équivaut à l’affectation t 4 t ff v
x %= y équivaut à l’affectation t 4 t W v
Égalités structurelle et physique
Pour tester l’égalité de deux objets, et # on a vu l’opérateur de

comparaison 44 #. Une variable est définie comme une adresse
sur le disque et une valeur enregistrée à cette adresse.
On peut donc distinguer deux sortes d’égalités pour des variables.
• t et v sont structurellement égales lorsqu’elles ont même valeur.
• t et v sont physiquement égales lorsqu’elles pointent vers la même
adresse sur le disque.
Lorsque ces variables sont de type non mutable (types numériques,
t-uplet, chaînes de caractères), ces deux notions d’égalité coïncident.
En effet, par définition, on ne peut modifier la valeur d’une variable
de type non mutable sans changer son adresse.
En revanche, lorsqu’il s’agit de listes, la différence existe : l’égalité
physique entraîne l’égalité structurelle mais la réciproque est fausse.
teste l’égalité structurelle de t et v, retourne un
x == y
booléen
x is y teste l’égalité physique de t et v, retourne un booléen
id(x) retourne l’adresse physique de la variable t
N
9
-JTUFT FO 1ZUIPO
.PEFT EF DPOTUSVDUJPO
Pour construire une liste, plusieurs manières sont possibles.
L=[] ou L=list() crée la liste vide

L=[a,b,c] crée la liste d’objets - #- +
convertit en liste tout type
list(A) d’objet composé (liste, t-uplet,
chaîne, ensemble)
L=[]
crée la liste par concaténation à
for i in iterable :
partir d’une expression dépen-
dant de l’indice B
. . . L = L + [expr[i]]
crée la liste G en dupliquant M
L = n*[a] ou L= [a]*n
fois la liste à un élément ()
crée la liste G en compréhension
L = [expr[i] for i in iterable] à partir d’une expression dépen-
dant de l’indice B
crée la liste de M entiers consécu-

range(n)
tifs de 0 à n − 1
crée la liste des entiers consécu-
range(n,m)
tifs de n à m − 1
crée la liste des entiers partant de
range(n,m,p)
n de p en p sans atteindre m
Remarque : Comme les listes sont des séquences d’objets de tous

types, on peut également construire et manipuler des listes de listes.
Par exemple, l’instruction suivante permet de créer en compréhen-
sion une liste de listes
(L[i][j]) 0in−1
0jm−1
Ry
10
L = [ [ e x p r [ j ] f o r j i n r a n g e (m) ] f o r i i n r a n g e ( n ) ]
On peut également utiliser des tableaux h(B-D) du type M/``v de

N UMPY.
0QÏSBUJPOT TVS MFT MJTUFT
Opérations communes pour les objets composés
len(L) retourne la longueur de la liste G

teste l’appartenance de l’objet t à la liste G, retourne
x in L
un booléen
L+M concaténation de deux listes
n*L duplication de la liste G
max(L) retourne l’objet maximal de la liste G
min(L) retourne l’objet minimal de la liste G
retourne la somme des éléments d’une liste de
sum(L)
nombres G
Accès aux éléments et extraction de sous-liste
L[i] accède à l’élément d’indice B de la liste G

L[-1] accède au dernier élément de la liste G
retourne la sous-liste des élements de G d’indice
L[i : j]
variant de B à D@R
L[i : j : k]
variant de B à D T` Tb /2 F bMb ii2BM/`2 D
L[i : ]
supérieur ou égal à de B
L[ : j]
strictement inférieur à D
L[ : ] retourne la liste de tous les élements de G
RR
11
.PEJmDBUJPOT EhVOF MJTUF
Affectation à un élément ou à un bloc d’éléments
L[i]=a remplace la valeur du terme d’indice B de la liste G

remplace la sous-liste des élements de G d’indice
L[i : j]=M variant de B à D@R par la liste J qui n’a pas néces-
sairement la même longueur
L[i, i+1]=[] supprime le terme d’indice B de la liste G
Copie d’une liste
Avant de modifier une liste G, il est parfois utile de créer une copie
de celle-ci, c’est-à-dire une nouvelle liste qui contient les mêmes élé-
ments que G.
M=L[ : ] crée une copie de la liste G
«Nous ne savons pas où nous allons, mais du moins il nous

reste bien des choses à faire.»
"MBO 5VSJOH, mathématicien anglais.
Rk
12
1SPHSBNNBUJPO FO 1ZUIPO
4USVDUVSFT TÏRVFOUJFMMFT DPOEJUJPOOFMMFT JUÏSB

UJWFT
/PUJPO EF QSPHSBNNF
Cinq types d’instructions
On appelle instruction tout ordre de modification de l’état courant

des variables. Les instructions sont les éléments constitutifs des pro-
grammes. Leur assemblage, dans un ordre précis conduit au résultat
attendu.
On distingue cinq types d’instructions :
• La déclaration de variable qui rajoute cette variable à l’état du sys-
tème ;
• L’affectation de variable qui modifie la valeur de la variable ;
• La séquence d’instructions qui exécute plusieurs instructions à la
suite l’une de l’autre ;
• L’instruction conditionnelle qui sert à n’exécuter une instruction
que dans certains états ;
• Les structures itératives qui exécutent plusieurs fois la même ins-
truction.
4ÏRVFODFT EhJOTUSVDUJPOT
En algorithmique, on délimite les groupes d’instructions par des mots

clés Faire et Fin Faire par exemple, ce qui permet de considérer ce
groupe comme une seule instruction.
Rj
13
En P YTHON, on groupe les instructions à l’aide de l’indentation (dé-
calage par rapport à la marge de gauche). Deux instructions de même
profondeur logique doivent avoir la même indentation.
en−t ê t e 1 :
instruction
en−t ê t e 2 :
instruction
...
instruction
instruction
instruction
*OTUSVDUJPOT DPOEJUJPOOFMMFT
Test simple
Une instruction conditionnelle n’est éxécutée que si une condition

(de type booléen) est vérifiée par l’état courant.
if condition :
i n s t r u c t i o n ou b l o c d ’ i n s t r u c t i o n s
Test avec alternative

Suivant la valeur (vraie ou fausse) d’une condition, on peut dévier le
flot d’instructions :
if condition :
else :
Test imbriqués
On peut scinder le flot d’instructions suivant plusieurs cas :

i f condition1 :
e l i f condition2 :
R9
14
...
e l i f condition n :
else :
Expressions conditionnelles
P YTHON offre la possibilité de former des expressions dont l’évalua-
tion est soumise à une condition. La syntaxe est la suivante :
expression1 i f condition else expression2
4USVDUVSFT JUÏSBUJWFT
Boucles inconditionnelles (boucles for)
Pour répéter un certain nombre de fois une instruction, on utilise la

construction suivante :
for i in i t e r a b l e :
On rappelle qu’un itérable est un objet de type liste, t-uplet, chaîne

de caractères ou ensemble.
Boucles conditionnelles (boucles while)
Lorsqu’on doit répéter un bloc d’instructions un certain nombre de

fois bien déterminé, ou plus généralement lorsqu’on souhaite parcou-
rir un iterable, on effectuera une boucle 7Q`. Mais lorsque le nombre
d’itérations n’est pas connu à l’avance et que la décision d’arrêter
la boucle ne peut s’exprimer que par un test, on choisira la boucle
r?BH2.
Pour répéter un bloc d’instructions tant qu’une condition est réalisée,
P YTHON propose la clause r?BH2 :
R8
15
while c o n d i t i o n :
bloc d ’ i n s t r u c t i o n s i condition est vraie
Remarques :
• Si condition est fausse dès le départ, le bloc qui suit n’est jamais
parcouru.
• Dans la plupart des cas, le bloc qui suit l’instruction d’en-tête
r?BH2 agit sur la condition, de sorte que celle-ci, vraie au départ,
devient fausse et provoque la sortie de la boucle.
• Lorsqu’on utilise une boucle conditionnelle, la question de sa ter-
minaison après un nombre fini d’itérations se pose systématique-
ment.
&OUSÏFT TPSUJFT
Affectation par l’utilisateur

Il existe une expression particulière, BMTmiUV, qui attend que l’utili-
sateur saisisse une chaîne de caractères au clavier. Cette expression
est alors affectée à une variable. Lorsque le résultat attendu est d’un
type autre que chaîne de caractères, une conversion est nécessaire.
>>> nom=i n p u t ( ’ E n t r e z v o t r e nom : ’ )
>>> age=i n t ( i n p u t ( ’ E n t r e z v o t r e age : ’ )
>>> t a i=f l o a t ( i n p u t ( ’ E n t r e z v o t r e t a i l l e en m : ’ )
Affichage d’une valeur

Inversement, l’instruction T`BMi affiche à l’écran les instructions
qui lui sont données en argument. Elle ne modifie pas l’état, mais
seulement l’aspect de l’écran. On s’en sert souvent pour afficher des
chaînes de caractères, mais elle peut afficher des expressions quel-
conques.
Re
16
'PODUJPOT FU NPEVMFT
Dans un même programme, une opération, ou une séquence d’opé-

rations peut intervenir à plusieurs reprises. En ce cas, il est intéres-
sant de définir une fonction qui exécute cette instruction (ou ce bloc
d’instructions). Elle pourra être appelée plusieurs fois dans un script
ou même dans plusieurs scripts.
Ainsi, une fonction en P YTHON est comme un sous-programme à
l’intérieur du programme principal. Il se constituera comme le pro-
gramme principal d’un en-tête et du corps de la fonction. Il pourra
aussi posséder ses propres variables, que l’on qualifiera de variables
locales.
'PODUJPOT
Définition d’une fonction
Une fonction est définie par la donnée de :

• son nom ;
• ses paramètres formels (les variables auxquelles seront appliquées
les instructions) ;
• éventuellement une valeur de retour, communiquée au programme
principal à la fin d’exécution.
La syntaxe P YTHON pour la définition d’une fonction est la suivante :

def nom_de_fonction ( l i s t e de p a r a m è t r e s f o r m e l s ) :
""" l a documentation """
instructions
r e t u r n ( v a l e u r de r e t o u r )
Le mot-clé /27 annonce la définition d’une fonction. Il doit être suivi

par le nom de la fonction et une liste entre parenthèses de paramètres
formels suivie de deux-points ’ :’. On trouve ensuite une documen-
Rd
17
tation (optionnelle), puis le corps de la fonction. Le mot-clé `2im`M
interrompt le déroulement de la fonction et renvoie la valeur précisée.
On peut également définir une fonction de façon plus succincte à
l’aide du mot-clé lambda lorsqu’elle est définie par une expression
simple, comme une fonction mathématique.
f=lambda x :3∗ x ∗∗2−6∗x−12
est équivalent à :
def f ( x ) :
r e t u r n ( 3 ∗ x ∗∗2−6∗x −12)
Appel d’une fonction
Lorsqu’on applique une fonction à des valeurs, il suffit de taper le

nom de la fonction et de passer les paramètres effectifs en arguments.
>>> f ( 2 )
−12
Variables locales
Lorsqu’on définit une fonction, on peut avoir besoin de variables.

Tout comme les paramètres formels, elles ne servent qu’à l’exécution
de la suite d’instructions qui mènent à la valeur de retour.
Fonctions récursives
Dans les paragraphes précédents, nous avons pris soin de distinguer

la définition d’une fonction de son appel. Toutefois, rien n’interdit
d’appeler une fonction lors de sa définition. C’est ce que l’on appelle
une fonction récursive. Un exemple classique est d’une programma-
tion récursive de la fonction factorielle.
def f a c t o ( n ) :
i f n==0 :
return (1)
R3
18
else :
r e t u r n ( n∗ f a c t o ( n −1))
Comme pour une boucle conditionnelle, la terminaison d’une fonc-

tion récursive pose question. Tout d’abord, il est primordial que la
fonction récursive possède un ou plusieurs cas d’arrêt (ici, lorsque M
est nul).
En outre, pour établir la terminaison, on utilisera souvent une suite
strictement décroissante d’entiers naturels, associés à chaque appel
récursif de la fonction (voir p. 24).
.PEVMFT FU QBDLBHFT
Les instructions import, from
P YTHON possède un très grand nombre de fonctions et de constantes.

Certaines, dites natives sont disponibles directement, mais la plupart
sont définies dans des modules, eux-mêmes regroupés en packages.
Tous ces modules ne sont pas chargés automatiquement au démar-
rage de P YTHON. Pour utiliser leurs fonctions, il faut d’abord les
importer. On dispose de plusieurs manières pour utiliser une fonc-
tion appelée « 7QM+iBQM » d’un module nommé « KQ/mH2 X
« Un ordinateur vous permet de faire plus de bêtises, beaucoup

plus rapidement, que n’importe quelle autre invention dans
l’histoire de l’humanité. À l’exception notable des armes à feu
et de la tequila.»
.JUDI 3BUDMJGGF, journaliste américain.
RN
19
charge tous les noms (fonctions,
import module
constantes) du module
on peut utiliser la fonction du
module.fonction
module avec ce préfixe
charge tous les noms du module
import module as md et lui donne un nom plus court
(alias)
on peut utiliser sous ce nom la
md.fonction
fonction du module
on peut directement utiliser la
from module import fonction
fonction sans préfixe
on peut utiliser directement
from module import * toutes les fonctions du module
sans préfixe
Packages et modules usuels
Voici quelques packages et modules parmi les plus fréquemment uti-

lisés.
module avec les fonctions et constantes mathéma-
math
tiques de base (sin, cos, exp, π . . . )
module permettant la génération de nombres
random
aléatoires
package notamment utile pour le traitement des
numpy tableaux multidimensionnels comme par exemple
des vecteurs, matrices, images
package utile pour algèbre linéaire, intégration,
scipy équations différentielles, traitement du signal et ima-
gerie, statistiques
module indispensable pour la représentation
matplotlib
graphique
permet d’accéder à l’heure de l’ordinateur et aux
time
fonctions gérant le temps
ky
20
permet d’évaluer le temps d’exécution de chaque
profile
fonction dans un programme
interface Python avec Tk qui permet de créer des
tkinter
objets graphiques
pygame permet de créer une interface graphique avec Python
'PODUJPOT OBUJWFT
Voici un résumé de fonctions directement accessibles en P YTHON.
abs(x) valeur absolue ou module d’un nombre

bin(x) convertit en binaire
chr(x) caractère de code donné entre 0 et 255
complex(x,y) convertit un couple de flottants en nombre complexe
divmod(x,y) quotient et reste de la division euclidienne
évalue la valeur numérique d’une chaîne de
eval(ch)
caractères
float(x) convertit en flottant
help(name) interroge l’aide en ligne sur un nom
hex(n) convertit en hexadécimal un nombre
input(ch) affiche une chaîne et récupère une entrée clavier
int(x) convertit en entier
len(x) longueur d’un objet composé
list(x) convertit un objet en liste
max(x) maximum d’un objet composé
min(x) minimum d’un objet composé
ord(ch) code (entre 0 et 255) d’un seul caractère
pow(x,y) élève à la puissance
print(ch) affiche une chaîne à l’écran
kR
21
range(n,m,p) construit un intervalle de valeurs
arrondit au nombre le plus proche à une précision
round(x,p)
donnée
set(x) convertit un objet en ensemble
sorted(x) crée une copie triée d’un iterable
str(ch) convertit en chaîne de caractères
calcule la somme des élément d’une séquence de
sum(x)
nombres
type(x) type d’un objet
'PODUJPOT EV NPEVMF NBUI
factorial(n) nombre factorielle de n

floor(x) partie entière d’un réel
frexp(x) couple mantisse et exposant d’un nombre
gcd(x,y) PGCD de deux entiers
exp(x) exponentielle d’un nombre
log(x) logarithme néperien d’un nombre
log2(x) logarithme en base 2 de x
log10(x) logarithme décimal de x
pow(x,y) élève à la puissance
sqrt(x) racine carrée
acos(x) arc cosinus d’un nombre
asin(x) arc sinus d’un nombre
atan(x) arc tangente d’un nombre
cos(x) cosinus d’un nombre
sin(x) sinus d’un nombre
tan(x) angente d’un nombre
degrees(x) convertit en degrés un angle exprimé en radians
radians(x) convertit en radians un angle exprimé en degrés
kk
22
cosh(x)
cosh(x) cosinus
cosinushyperbolique
hyperboliqued’un
d’unnombre
nombre
sinh(x)
sinh(x) sinus
sinushyperbolique
hyperboliqued’un
d’unnombre
nombre
tanh(x)
tanh(x) tangente
tangentehyperbolique
hyperboliqued’un
d’unnombre
nombre
pi
pi constante
constanteππ
e constante
constanteee
4QÏDJmDBUJPO
4QÏDJmDBUJPO UFSNJOBJTPO
UFSNJOBJTPO DPSSFDUJPO
DPSSFDUJPO DPNQMFYJUÏ
DPNQMFYJUÏ
1SFVWF
1SFVWF EF
EF QSPHSBNNF
QSPHSBNNF
Faire
Faire une
une preuve
preuvede
deprogramme
programmeconsiste
consisteààvérifier
vérifierque
queleleprogramme
programme
s’applique
s’applique dans
danstous
tousles
lescas
casprévus
prévusetetconduit
conduitenentemps
tempsfini
finiauaurésultat
résultat
attendu.
attendu.
Une
Une preuve
preuve de
de programme
programmerepose
reposesur
surplusieurs
plusieursétapes
étapesdécrites
décritesbriè-
briè-
vement
vement ci-après.
ci-après.
• Spécification
Spécification
• Terminaison
Terminaison
• Correction
Correction
• Complexité
Complexité
4QÏDJmDBUJPO
4QÏDJmDBUJPO
Un programme
programme ou ou une
une fonction
fonctionenenPPYTHON
YTHONressemble
ressembleà àune unefonc-
fonc-
tion
tion mathématique
mathématique comprenant
comprenantun unensemble
ensembledededépart,
départ,ununensemble
ensemble
d’arrivée,
d’arrivée, et
et un
un procédé
procédé qui
quitransforme
transformetout
toutélément
élémentdedel’ensemble
l’ensemble
de départ
départ en
en un
un élément
élémentde del’ensemble
l’ensembled’arrivée.
d’arrivée.
La spécification
spécificationd’und’unprogramme
programmeou oud’une
d’unefonction
fonctionconsiste
consisteà àdécrire
décrire
le problème
problème qu’il
qu’il doit
doitrésoudre,
résoudre,lelecalcul
calculààeffectuer,
effectuer,etetdans
dansquelles
quelles
conditions
conditions ilil doit
doitlelefaire.
faire.Plus
Plusprécisément,
précisément,lalaspécification
spécificationindique
indique: :
• quelles
quelles sont
sont les
lesdonnées
donnéesen enentrée
entrée(leur
(leurtype
typenotamment),
notamment),qu’elles
qu’elles
soient
soient saisies
saisies par
par l’utilisateur
l’utilisateurou
oupassée
passéeenenparamètre
paramètrelors
lorsdedel’appel
l’appel
d’une
d’une fonction
fonction;;
kj
kj
23
• quelles sont les valeurs attendues en retour, leur type et à quoi elles
correspondent.
5FSNJOBJTPO
Lorsque le programme ne comporte que des boucles incondition-

nelles, il est certain de se terminer après un nombre fini de passages
en boucle.
Cependant, lorsque le programme utilise une boucle conditionnelle
r?BH2, il y a un risque de voir la boucle se répéter indéfiniment ! Il est
donc nécessaire, lors de l’écriture du programme de prouver la ter-
minaison de la boucle, c’est-à-dire qu’après un certain nombre d’ité-
rations, qui dépendra évidemment des données, mais qui est toujours
fini, la condition ne sera plus vérifiée.
L’argument est souvent lié à la propriété suivante :
Toute suite (Nk )k∈N d’entiers naturels décroissante est finie, c’est-
à-dire stationnaire.
$PSSFDUJPO
Sachant que la boucle se termine, encore faut-il garantir qu’elle re-

tourne le résultat escompté. Une des manières les plus efficaces pour
tester la correction d’un programme reposant sur une boucle while
ou for est d’établir un invariant de boucle, c’est-à-dire une pro-
priété mathématique qui est préservée tout au long de l’exécution
de la boucle.
Cette démarche est à rapprocher du raisonnement par récurrence : en
connaissant les valeurs initiales des variables et à leur évolution au
cours d’une itération, on peut en déduire des propriétés valides quel
que soit le nombre d’itérations. Plus précisément :
Un invariant de boucle est une propriété mathématique qui :
• est vérifiée avant d’entrer dans la boucle ;
k9
24
• si elle est vérifiée avant une itération, elle est aussi vérifiée après
celle-ci ;
• le fait qu’elle soit vérifiée en sortie de boucle, garantit que le pro-
gramme est correct.
$PNQMFYJUÏ
Efficacité d’un programme

On dit d’un programme qu’il est efficace d’une part si son exécution
est rapide et d’autre part, si les ressources mémoire qu’il mobilise
sont limitées. Bien sûr, ces deux critères sont liés : il est naturel que
plus un programme traite de données, plus le temps d’exécution est
important.
Opérations élémentaires
Il est difficile d’évaluer le temps d’exécution d’un algorithme car le
résultat dépend des capacités de la machine et du langage de pro-
grammation choisi.
Par contre on peut assez aisément compter le nombre d’opérations
élémentaires (OPEL) effectuées par celui-ci. Il peut s’agir
• d’une opération algébrique élémentaire : addition, soustraction,
multiplication, division ;
• d’un test de comparaison : égalité, inégalité ;
• d’une affectation d’une variable ;
• d’un affichage ou retour d’un résultat.
En outre, ceci est indépendant du langage de programmation et des
capacités de la machine !
k8
25
Complexité
Le nombre d’opérations à effectuer dans un programme augmente
avec le nombre de données à traiter. Pour savoir si un programme
est efficace, il est intéressant de connaître le rapport entre le nombre
de données et le nombre d’opérations surtout lorsque le nombre de
données devient important.
Soit n le nombre de données d’un programme et f (n) une fonction
de n. On dit que la complexité d’un programme est un O(f (n)) si
son coût (en terme de nombre d’OPEL) est inférieur à C.f (n), où C
est une constante indépendante de n.
Le tableau ci-dessous indique un ordre de grandeur des temps d’exé-
cution d’un problème de taille n = 106 sur un ordinateur à un mil-
liard d’opérations par seconde.
Complexité Nom courant Temps

O(1) temps constant 1 ns
O(HM(n)) logarithmique 10 ns
O(n) linéaire 1 ms
O(n2 ) quadratique 15 min
O (nk ) polynomiale 30 ans pour k = 3
O(2n ) exponentielle 10300 000 milliards d’années
« Il y a deux façons de faire la conception d’un logiciel. Une

façon est de le rendre si simple qu’il n’y a selon toute apparence
aucun défaut. Et l’autre est de le faire si compliqué qu’il n’y a
pas de défaut apparent. »
5POZ )PBSF, informaticien britannique.
ke
26
1ZUIPO QPVS MhJOHÏOJFSJF
OVNÏSJRVF FU MB TJNVMBUJPO
5BCMFBVY BWFD /VNQZ
P YTHON propose non pas des tableaux mais des listes : elles peuvent
contenir des objets de types divers (on dit qu’elles sont hétérogènes)
et de taille variable.
Le type nd.array de N UM P Y est constitué de « vrais » tableaux :
homogènes et de taille fixe. Ainsi, leur manipulation est optimisée et
beaucoup plus efficace que celle des listes.
Pour des raisons de lisibilité, on suppose que N UMPY a été importé
par :
from numpy import ∗
En important N UMPY avec l’alias MT, tous les noms de fonctions

devairent être préfixés par MT.
.PEFT EF DPOTUSVDUJPO EF UBCMFBVY
On utilise surtout, des tableaux de dimension 1 (vecteurs) ou 2 (ma-

trices), mais les tableaux peuvent être multidimensionnels. Leur forme
ou dimension est un t-uplet d’entiers, appelée b?T2 par N UM P Y.
array(L) convertit une liste P YTHON en un tableau

crée un tableau de n lignes, m colonnes sans initia-
empty((n,m))
liser les valeurs
crée un tableau de n lignes, m colonnes avec tous
zeros((n,m))
ses coefficients nuls
kd
27
crée un tableau de n lignes, m colonnes avec tous
ones((n,m))
les coefficients égaux à 1
identity(n) crée la matrice identité d’ordre n
analogue à `M;2 mais renvoie un tableau de type
arange(n,m,p)
M/``v
renvoie une subdivision régulière de [x, y] en n élé-
linspace(x,y,n)
ments régulièrement espacés
$BSBDUÏSJTUJRVFT EhVO UBCMFBV
Quelques fonctions permettent de trouver les caractéristiques d’un

tableau.
Dimensions d’un tableau

indique le format du tableau A, sous la forme du
shape(A)
t-uplet du nombre d’éléments dans chaque direction
donne la première dimension d’un tableau (la taille
alen(A) pour un vecteur, le nombre de lignes pour une
matrice)
donne la dimension du tableau, soit le nombre d’in-
ndim(A) dices nécessaire au parcours du tableau (1 pour un
vecteur, 2 pour une matrice)
donne le nombre total d’éléments du tableau (n × p
size(A)
pour une matrice de type n lignes p colonnes
À noter également, la fonction `2b?T2U-UM-KVV permet de redi-
mensionner un tableau au format UM-KV pourvu que possède
n × m éléments.
Type de tableau
Les éléments d’un tableau N UM P Y sont tous du même type. On

trouve notamment des tableaux de type : booléen, entier, flottant,
complexe. On peut aussi former des tableaux de chaînes de carac-
tères de longueur fixée.
k3
28
Le type de tableau est choisi par la fonction ``v en fonction des
coefficients lors de la conversion. Pour les autres procédés de construc-
tion, on peut imposer le type de tableau en ajoutant le paramètre
optionnel /ivT24 ~Qi par exemple.
-FDUVSF FU ÏDSJUVSF EBOT VO UBCMFBV
Accès aux éléments et coupes
Les conventions pour l’accès aux éléments d’un tableau sont celles
des listes (voir p 11). En particulier, pour un tableau de dimension
2 à n lignes et m colonnes, les indices de ligne et de colonne varient
de 0 à n − 1 et de 0 à m − 1 respectivement.
A[i , j] accède à l’élément d’indice (i, j)

A[i, :] ou A[i] retourne le vecteur iième ligne
A[ : , j] retourne le vecteur j ième colonne
retourne la sous-matrice formée des i premières

A[ : i , : j]
lignes et des j premières colonnes
retourne la sous-matrice constituée coefficients ai,j
A[i1:i2,j1:j2]
avec i1 i < i2 et j1 j < j2
Modifications d’un tableau
Comme on peut accéder directement aux éléments et aux coupes, on

peut également les remplacer.
A[i , j]=b remplace l’élément d’indice (i, j) par #

A[i] =B remplace la iième ligne par le vecteur "
A[ : , j]= B remplace la j ième colonne par le vecteur "
kN
29
0QÏSBUJPOT
0QÏSBUJPOTTVS
TVSMFT
MFTUBCMFBVY
UBCMFBVY
Opérations
Opérations algébriques
algébriques
De façon
façon générale,
générale,les
lesopérations
opérationsalgébriques
algébriquesentre
entretableaux
tableauxdede
type
type
M/``v
M/``v s’entendent
s’entendentcoefficient
coefficientpar
parcoefficient.
coefficient.Ainsi
Ainsi
additionne
additionne terme
terme ààterme
termedes
destableaux
tableauxdedemême
même
A+B
A+B
taille
taille
A*B
A*B multiplie
multiplieterme
termeààterme
termedes
destableaux
tableauxdedemême
mêmetaille
taille
x*A multiplie partttous
multipliepar tousles coefficientsdede
lescoefficients
x+A
x+A ajoutettààtous
ajoute tousles coefficientsdede
lescoefficients
Attention :: L’opérateur
Attention L’opérateur**multiplie
multiplieterme
termeà àterme
termedeux
deuxtableaux
tableaux
de même
même dimension,
dimension, ilil ne
ne s’agit
s’agitpas
pasduduproduit
produitmatriciel
matricielauausens
sens
mathématique
mathématique du
duterme.
terme.
Statistiques
Statistiques élémentaires
élémentairessur
surun
untableau
tableau
Voici quelques
quelquesopérations
opérationsstatistiques
statistiquesqu’on
qu’onpeut
peutréaliser
réalisersursurununtableau
tableau
de nombres
nombres en en dimension
dimension1.1.Ces Cesopérations
opérationss’appliquent
s’appliquentégalement
également
aux tableaux
tableaux multidimensionnels.
multidimensionnels.IlIlfaut fautalors
alorschoisir
choisirununaxe axededecal-
cal-
cul, en
en rajoutant l’option-tBb4·
rajoutant l’option -tBb4·· · ·. .Par
Pardéfaut,
défaut,l’axe
l’axeestest0 0etetonon
tra-
tra-
vaillera
vaillera colonne
colonnepar
parcolonne.
colonne.
sum(a)
sum(a) retourne
retournelalasomme
sommedes élémentsdede
deséléments
prod(a)
prod(a) retourne
retourneleleproduit
produitdes élémentsdede
deséléments
max(a)
max(a) retourne
retournelelemaximum
maximumdes élémentsdede
deséléments
min(a)
min(a) retourne
retourneleleminimum
minimumdes élémentsdede
deséléments
mean(a)
mean(a) retourne
retournelalamoyenne
moyennedes élémentsdede
deséléments
var(a)
var(a) retourne
retournelalavariance
variancedes élémentsdede
deséléments
jy
jy
30
Fonctions universelles
Si est un tableau unidimensionnel de nombres, et f est une fonction

numérique, on aura souvent intérêt à appliquer la fonction f à tous les
éléments de . Les fonctions mathématiques de N UMPY s’appliquent
directement à des vecteurs, on dit qu’elles sont universelles.
On retrouve ici les fonctions usuelles en version « universelle » :bBM-
+Qb- iM- `+bBM- `++Qb- `+iM- +Qb?- bBM?- iM?- 2tT- HQ;- HQ;k-
HQ;Ry, etc.
0VUJMT QPVS MhJOHÏOJFSJF OVNÏSJRVF MB TJNVMBUJPO
$BMDVM OVNÏSJRVF NBUSJDJFM BWFD MJOBMH
Le module HBMH; de N UMPY est riche de nombreuses fonctions. En

voici quelques unes. On suppose ici les modules importés avec :
from numpy import ∗
import numpy . l i n a l g a s l a
Opérations basiques sur les matrices
réalise le produit matriciel au sens mathématique du

dot(M,N)
terme
la.matrix_ réalise la puissance nième d’une matrice carrée
power(M,n)
réalise la combinaison linéaire des matrices M et N
a*M+b*N
Inverse, déterminant d’une matrice
la.inv(A) retourne l’inverse d’une matrice carrée

la.det(A) calcule le déterminant d’une matrice carrée
jR
31
trace(A)
trace(A) trace
tracededelalamatrice
matricecarrée
carrée
transpose(A)
transpose(A) transposée
transposéedede
Résolution
Résolution d’un
d’unsystème
systèmed’équations
d’équationslinéaires
linéaires
solution
solutiondudusystème
systèmed’équations
d’équations
linéaires
linéaires
la.solve(A,B)
la.solve(A,B) (S)
(S) AX
AX= =
BB
Réduction
Réduction des
des matrices
matrices
la.eigvals(A)
la.eigvals(A) retourne
retourneles
lesvaleurs
valeurspropres
propres
dede
la la
matrice
matrice
carrée
carrée
retourne
retourne enenplus
plusleslesvecteurs
vecteurspropres
propres
(unitaires)
(unitaires)
la.eig(A)
la.eig(A)
associés
associés
"OBMZTF
"OBMZTFOVNÏSJRVF
OVNÏSJRVFBWFD
BWFD4DJQZ
4DJQZ
Résolution
Résolution numérique
numériqued’équations
d’équationsavec
avecoptimize
optimize
moduleoptimize
Le module optimizededeSSCICIPP
YYpermet
permetdede
calculer
calculer
desdes
valeurs
valeurs
approchées
approchées
des zéros
zéros d’une
d’unefonction.
fonction.
retourne
retourneune
unesolution
solutiondedel’équation
l’équation
f (x)
f (x)= =0, 0,
fsolve(f,a)
fsolve(f,a)
proche
prochededea.a.
Intégration
Intégration numérique
numériqueavec
avecintegrate
integrate
fonction quad
La fonction quaddu moduleintegrate
dumodule integratedede
S CI
SP CIYPpermet
Y permet
de de
cal-cal-
culer
culer de
de façon
façonapprochée
approchéedes
desintégrales.
intégrales.
retourne
retourneune unevaleur
valeurapprochée
approchéedede
l’intégrale
l’intégrale
de de
f f
quad(f,a,b)
quad(f,a,b)
entre
entreaaetetb b(qui
(quipeuvent
peuventêtre
être
infinis)
infinis)
jkjk
32
Équations
Équations différentielles
différentielles avec
avec integrate
integrate
On considère
considère le
le problème
problèmede
deCauchy
Cauchysuivant
suivant: :

yy (t)
(t) == ff(y(t),
(y(t),t)t)
(C)
y(t
y(t00)) == yy00
où y est une
une fonction
fonction àà valeurs
valeursréelles
réellesou
ouvectorielles.
vectorielles.
retourne
retourne des
des valeurs
valeurs approchées
approchéesdedelalasolution solutiondudu
odeint(f,y0,t)
odeint(f,y0,t)
problème
problèmede deCauchy
Cauchy(C). (C).
Ici, i est un
un tableau
tableau de
de valeurs
valeurs de
de lala forme
formett == [t[t0 ,0 t, 1t,1..., n ].La
, ...,tnt]. La
solution retournée
retournée correspond
correspond àà lala distribution
distributiondes desvaleurs
valeursappro-
appro-
chées de f aux
aux différents
différentsinstants
instantstt00,,tt11, ,. .. . ., ,tntn. .
4JNVMBUJPO
4JNVMBUJPO OVNÏSJRVF
OVNÏSJRVF BWFD
BWFDSBOEPN
SBOEPN
module `M/QK
Le module `M/QK de
de N
NUMPY
UMPY permet
permetde
deréaliser
réaliserdes
destirages
tiragesaléa-
aléa-
toires.
random()
random() choisit
choisit un
unréel
réelaléatoire
aléatoiredans
dans[0,
[0,1]1]
uniform(x,y)
uniform(x,y) choisit
choisit un
unréel
réelaléatoire
aléatoiredans
dans[x,
[x,y]y]
randrange()
randrange() choisit
choisit un
unentier
entieraléatoire dans`M;2UM-K-TV
aléatoiredans `M;2UM-K-TV
randint(n,m)
randint(n,m) choisit
choisit un
unentier
entieraléatoire
aléatoiredans
dans[[n,
[[n,m]]
m]]
choice(x)
choice(x) choisit
choisit un
unélément
élémentaléatoire
aléatoiredans
dansune
uneséquence
séquence
N UM P YY propose
propose également
également tout
tout un
un jeu
jeude
dedistributions
distributionsstandards.
standards.
Cette fois, sisi on
on veut
veutplusieurs
plusieursvaleurs,
valeurs,ononutilisera
utiliseral’argument
l’argumentoptionnel
optionnel
bBx2 4 · · · ..
normal(m,s)
normal(m,s) simule
simule une
uneloi
loinormale
normalede
deparamètre
paramètrem,
m,ss
binomial(n,p)
binomial(n,p) simule
simule une
uneloi
loibinomiale
binomialede
deparamètres
paramètresnnetetpp
geometric(p)
geometric(p) simule
simule une
uneloi
loigeometrique
geometriquede
deparamètre
paramètrepp
poisson(x)
poisson(x) simule
simule une
uneloi
loide
depoisson
poissonde
deparamètre
paramètrexx
jj
jj
33
(SBQIJRVFT BWFD NBUQMPUMJC
Le module KiTHQiHB#XTvTHQi permet de tracer des graphiques dans

une fenêtre séparée. L’utilisation de base de cette fonction est plot
(x,y) où x et y sont des tableaux d’abscisses et d’ordonnées, en fait,
ce sont les coordonnées cartésiennes des points du graphe.
clf() efface la fenêtre graphique

plot(x,y) trace les points de coordonnées (x, y)
grid() affiche la grille
axis([a,b,c,d] fixe les axes de coordonnées de [a, b] × [c, d]
xlabel(ch) ch est l’étiquette des abscisses (chaîne de caractères)
exporte et enregistre la figure au format donné dans
savefig() l’extension précisé en argument (mafigure.pdf par
exemple)
« La science est ce que nous comprenons suffisamment bien

pour l’expliquer à un ordinateur. L’art, c’est tout ce que nous
faisons d’autre. »
%POBME ,OVUI, informaticien américain.
j9
34
#BTFT EF EPOOÏFT
FU BMHÒCSF SFMBUJPOOFMMF
"MHÒCSF SFMBUJPOOFMMF
On présente d’abord le vocabulaire de l’algèbre relationnelle avant

de donner la description des commandes SQL à connaître ainsi que
leur équivalent en algèbre relationnelle.
7PDBCVMBJSF EhBMHÒCSF SFMBUJPOOFMMF
On considère un ensemble fini A, dont on appelle les éléments les

attributs. On note D un ensemble et dom une application de A dans
P(D).
Pour tout attribut A ∈ A on appelle domaine de A l’ensemble
dom(A).
On appelle schéma relationnel un n-uplet de la forme
S = (A1 , . . . , An ) ∈ An
où les Ai sont distincts deux à deux.
On appelle relation ou table associée au schéma relationnel S un
sous-ensemble de dom(A1 ) × · · · × dom(An ).
On note R(S) une relation R si on souhaite préciser qu’elle est asso-
ciée au schéma relationnel S.
-FT PQÏSBUJPOT EhBMHÒCSF SFMBUJPOOFMMF
On peut distinger les opérations ensemblistes et les opérations rela-

tionnelles d’autre part.
j8
35
Les opérations ensemblistes sont :
• l’union R1 ∪ R2 de deux relations R1 (S) et R2 (S) est l’en-
semble des éléments appartenant à R1 ou à R2 ,
• l’intersection R1 ∩ R2 de deux relations R1 (S) et R2 (S) est
l’ensemble des éléments appartenant à la fois à R1 et à R2 ,
• la différence R1 \ R2 de deux relations R1 (S) et R2 (S) est
l’ensemble des éléments appartenant à R1 mais pas à R2 .
Les opérations relationnelles sont :
• la sélection σC (R1 ) est l’ensemble des éléments de R1 (S)
satisfaisant la condition logique C,
• la projection πA1 ,...,Am de la relation R1 (S) est l’ensemble
des éléments obtenus par projection ensembliste de R1(S) sur
dom(A1 ) × · · · × dom(Am ),
• le produit cartésien R1 × R2 de deux relations R1 (S1 ) et
R2 (S1 ) est l’ensemble {(x1 , x2 ), x1 ∈ R1 , x2 ∈ R2 },
• la jointure R1 [C]R2 de deux relations R1 (S1 ) et R2 (S1 ) est
l’ensemble des éléments du produit R1 × R2 satisfaisant la
condition C,
• la division R1 ÷ R2 de deux relations R1 (S1 ) et R2 (S2 ) telles
que S2 = (A1 , . . . , Am ) et S1 = (A1 , . . . , Am , Am+1 , . . . , An )
est l’ensemble des éléments x images par la projection de R1
sur (Am+1 , . . . , An ) tels que le produit {x} × R2 soit inclus
dans R1 .
$PNNBOEFT 42-
Opérations SQL : opérations ensemblistes
permet d’effectuer l’union R1 ∪ R2 des éléments

UNION de deux tables R1 (S) et R2 (S) de même schéma
relationnel
je
36
permet d’effectuer l’intersection R1 ∩ R2 des élé-
INTERSECT ments de deux tables R1 (S) et R2 (S) de même
schéma relationnel
permet d’effectuer la différence ensembliste R1 \R2
EXCEPT des deux tables R1 (S) et R2 (S) de même schéma
relationnel
On peut en fait effectuer en SQL ces opérations si les schémas rela-
tionnels des deux relations sont différents, à condition qu’elles aient
le même nombre d’attributs et des domaines identiques. On dit alors
que les schémas sont identiques.
Autres opérateurs à schéma relationnel fixé
Les instructions décrites ici sont les instructions de construction de

table à partir d’une base de données et d’un schéma relationnel. On
précise comment les faire correspondre à telle ou telle opération
d’algèbre relationnelle.
c’est l’instruction de début de construction de table.
Suivie de * elle prendra tous les attributs possibles,
SELECT
suivie de A1 , . . . , Am elle permet d’effectuer la pro-
jection πA1 ,...,Am sur ces attributs
suivie d’une condition logique C, elle permet
WHERE d’effectuer la sélection σC ne conservant que les
éléments satisfaisant C
A as B permet d’effectuer le renommage ρA←B de
AS
l’attribut A en B
Pour créer des conditions en SQL, on peut utiliser <, >, =, ainsi
que les connecteurs logiques AND, OR. Les opérateurs suivants font
intervenir des relations de schémas différents.
Opérations complexes
permet d’effectuer le produit cartésien R1 × R2 de
JOIN
deux relations R1 et R2 .
jd
37
située après un JOIN, et suivie d’une condition C,
elle permet d’effectuer la jointure R1 [C]R2 des
ON deux tables considérées c’est à dire de ne garder
dans le produit cartésien que les éléments satisfai-
sant C.
suivie de A1 , . . . , Am et si on a indi-
qué A1 , . . . , Am , f (Am+1 , . . . , An ) comme
GROUP BY attributs après le SELECT, cette instruction
effectue l’aggrégation γ(Am+1 , . . . An ) →
f (Am+1 , . . . , An )
La division cartésienne R1 ÷ R2 n’a pas de réalisation immédiate
en SQL et nécessite une combinaison des commandes présentées ci-
dessus pour être réalisée.
On signale également la commande DISTINCT qui, placée directe-
ment après SELECT, permet de ne garder qu’une seule occurence de
chaque élément dans la table.
On présente enfin quelques unes des fonctions pouvant être utilisées
dans les aggrégations.
Fonctions d’aggrégation
compte les éléments. On peut l’utiliser suivie de
COUNT DISTINCT pour éviter de compter plusieurs fois les
mêmes éléments
MAX donne le maximum des éléments
MIN donne le minimum des éléments
SUM donne la somme des éléments
AVG donne la moyenne des éléments
j3
38
%FVYJÒNF QBSUJF
"-(03*5).&4 %& 13&.*µ3& "//²&
Partie 2
Algorithmes
de première année
Informatique
Le mot informatik fut créé par l’ingénieur allemand Karl
Steinbuch en 1957. C’est ce qu’on appelle un mot-valise
c’est-à-dire obtenu comme contraction de deux mots ;
dans ce cas, il s’agissait des mots information et automatique.
LE SAVIEZ-VOUS ?
À cette époque là, en effet, l’utilisation de l’informatique se

diversifie et l’on commence à voir son rôle dans le traitement
de l’information.jN
L’introduction dans notre langue du terme francisé
informatique date de 1962. Elle est l’œuvre de Philippe
Dreyfus, alors directeur du centre national de calcul
électronique de la société Bull.
La terminaison en –ique est heureuse car sa similarité avec
celle de noms de sciences proches comme mathématiques
ou physique donne à cette discipline naissante ses lettres
de noblesse.
1SPHSBNNFS BWFD MFT SÏFMT
4PNNFT FU QSPEVJUT mOJT
Étant donné une suite (�k )k∈N de nombres réels, on peut calculer les
sommes ou produits finis :
m
m

S(n, m) = �k et P (n, m) = �k ,
k=n k=n
où n et m sont des entiers naturels tels que n < m.
-FT BMHPSJUINFT
Fonction Somme( L , n ,m)
Donnees
L : l i s t e de r é e l s
S : réel
k , n ,m : e n t i e r s
Debut
S <−− 0
Pour k v a r i a n t de n à m
Faire
S <−− S + L [ k ]
Fin F a i r e
Retourner ( S )
Fin
Fonction P r o d u i t ( L , n ,m)
Donnees
P : réel
Debut
9y
40
P <−− 1
Pour k v a r i a n t de n à m
Faire
P <−− P ∗ L [ k ]
Fin F a i r e
Retourner (P)
Fin
Analyse de ces algorithmes :

Ces deux algorithmes étant semblables, nous ne traitons que de l’ana-
Algorithmes de 1re année

lyse de la fonction aQKK2.
Spécification : La fonction aQKK2 prend en entrée une liste de
nombres réels ainsi que deux indices M et K. En sortie, elle retourne
la valeur de la somme : L[n] + L[n + 1] + · · · + L[m].
Correction : Notons pour tout entier naturel k, �k = L[k] et Sk la
valeur de la variable informatique a à l’entrée du passage en boucle
inconditionnelle d’indice k. Vérifions qu’un invariant de boucle est
la propriété :
k−1

(Pk ) Sk = �i
i=n
• Initialisation : Lorsque k = n, Sn est initialisé à 0, ce qui cor-

n−1
respond bien à la somme sans terme : �i .
i=n
• Hérédité : Soit k n tel que Pk . Dans la boucle d’indice k,
l’instruction informatique :
a I@@ a Y G(F)
se traduit par la relation mathématique :
Sk+1 = Sk + �k .
Compte tenu que Pk est vrai par hypothèse, il en résulte que :

k−1
k

Sk+1 = �i + � k = �i .
i=n i=n
9R
41
La propriété Pk+1 est vérifiée.
• Conclusion : Lors du dernier passage en boucle, Sm est égal à

m−1
�i . À l’issue de ce dernier passage, la valeur retournée est
i=n
m

Sm+1 = �i .
i=n
Complexité : Pour chaque passage en boucle, on peut distinguer
3 opérations élémentaires (OPEL) : une somme et deux affectations

(celle de a et celle de F). En dehors de la boucle, il y a 2 OPEL :
l’initialisation de a et le retour du résultat. Ainsi, la complexité de
cet algorithme est de 3(m − n) + 5.
-FT QSPHSBNNFT FO 1ZUIPO

def Somme( L , n ,m) :
S=0
f o r k i n r a n g e ( n ,m+1) :
S=S+L [ k ]
return (S)
def P r o d u i t ( L , n ,m) :
P=1
f o r k i n r a n g e ( n ,m+1) :
P=P∗L [ k ]
r e t u r n (P)
#PÔUF Ë PVUJMT
cette fonction prédéfinie de
sum(L) P YTHON calcule la somme des
éléments d’une liste
calcule leur produit, mais
prod(L) il s’agit d’une fonction de
N UMPY.
9k
42
1VJTTBODFT EhVO SÏFM
Les puissances successives d’un réel a sont un cas particulier de cal-

cul de produit fini. On peut donc utiliser un algorithme proche de
la fonction T`Q/mBiUG-M-KV. Toutefois, il est possible d’obtenir ce
même résultat avec une complexité bien meilleure.
Pour comprendre cet algorithme dit d’exponentiation rapide consi-
dérons les deux expressions de a4 par exemple :

a4 = ((a × a) × a) × a
a4 = (a × a)2
La première expression de a4 nécessite trois multiplications, tandis

que la deuxième n’en coûte que deux !
-hBMHPSJUINF OBÕG
Fonction P u i s s a n c e _ n a i f ( a , n )
Donnees
a ,P : r e e l s
k,n : entiers
Debut
P <−− 1
Pour k v a r i a n t de 1 à n
Faire
P <−− P ∗ a
Fin F a i r e
Retourner (P)
Fin
Analyse de cet algorithme :

Spécification : Cette fonction prend en entrée un réel a et un
entier naturel n et retourne la valeur de an .
Terminaison : Cette boucle inconditionnelle se termine après n
itérations.
9j
43
Correction : On note pour tout entier naturel k 0, Pk la valeur
de la variable S après k passages en boucle. On vérifie qu’un inva-
riant de boucle est ici :
(Pk ) Pk = ak
Complexité : Pour cet algorithme naïf, il y a 3 OPEL par passage

dans la boucle. La complexité de l’algorithme est linéaire puisque le
nombre d’OPEL s’évalue à 3n + 2.
-F QSPHSBNNF FO 1ZUIPO
def P u i s s a n c e _ n a i f ( a , n ) :
P=1
for k in range (n) :
P=P∗ a
r e t u r n (P)
-hBMHPSJUINF SBQJEF
Fonction P u i s s a n c e _ r a p i d e ( a , n )
Donnees
a, b, P : reels
Debut
P <−− 1
b <−− a
m <−− n
Tant que m>0
Faire
S i m%2=1
A l o r s P <−− P ∗ b
b <−− b∗b
m <−− m//2
Fin F a i r e
Retourner (P)
Fin
99
44
Notation : dans cet algorithme, nous avons noté KWk et Kffk le
reste et le quotient de la division euclidienne de m par 2.
Spécification : C’est évidemment la même que celle de la pré-
cédente fonction SmBbbM+2nMB7.
Terminaison : Notons pour tout entier k 0, Pk ,bk , mk les
valeurs des variables informatiques S, #, K après k passages en boucles.
On observe que pour tout entier k, mk+1 est le quotient dans la divi-

sion euclidienne de mk par 2. Ainsi :
mk+1 12 mk
La suite d’entiers naturels (mk )k est donc strictement décroissante.

Elle est donc nécessairement finie.
Correction : Montrons qu’un invariant de boucle est ici la pro-
priété
(Pk ) Pk × bm k
k =a
n
• Initialisation : Lorsque k = 0, P0 = 1, b0 = a et m0 = n, de
sorte que P0 × bm
0 =1×a =a .
0 n n
• Hérédité : Soit k 0 tel que Pk . À l’entrée du k +1ième passage

en boucle, on distingue deux cas :
Si mk est pair alors bk+1 = b2k , mk+1 = 12 mk , tandis que S est
inchangé, Pk+1 = Pk . Il en résulte que :
mk+1 1m
Pk+1 × bk+1 = Pk × b2k 2 k = Pk × bm k
k =a .
n
Si mk est impair Pk+1 = Pk × bk , bk+1 = b2k et mk+1 = mk //2,

soit mk = 2mk+1 + 1. En ce cas,
mk+1 m 2m +1
Pk+1 ×bk+1 = Pk ×bk × b2k k+1 = Pk bk k+1 = Pk bm k
k =a .
n
Dans tous les cas, Pk+1 est bien vérifiée.

• Conclusion : En sortie de boule, après N passages, on a mN =
0. PN donne alors
an = PN × b0N = PN
98
45
La valeur retournée est bien égale à an .
Complexité : Chaque passage en boucle nécessite ici 9 OPEL
contre 3 dans l’algorithme naïf. Mais le nombre d’itérations est bien

plus faible. En effet, comme nous l’avons observé, pour tout entier
k 0, mk+1 12 mk , de sorte que
n
mN N
2
Par conséquent, mN est nul dès que 2N > n, c’est-à-dire lorsque
HM(n)
N> = HQ;2 (n).
HM(2)
Finalement, la complexité de cet algorithme rapide est logarithmique
puisque le nombre d’OPEL s’évalue à 9N + 4, où N = HQ;2 (n).
def P u i s s a n c e _ r a p i d e ( a , n ) :
P=1
b=a
m=n
w h i l e m>0 :
i f m%2==1 :
P=P∗b
b=b∗b
m=m//2
r e t u r n (P)
#PÔUF Ë PVUJMT
retourne la valeur de x à la puis-
pow(x,y) sance y, avec x > 0 et y des
réels.
x**y idem en version plus pratique
9e
46
²WBMVBUJPO QPMZOPNJBMF
Soit P un polynôme de degré n et x ∈ R. On souhaite évaluer P en

x, c’est-à-dire calculer la valeur de P (x).
P (x) = a0 + a1 x + a2 x2 + · · · + an xn
Pour ce faire, il existe deux algorithmes « concurrents ».
-hBMHPSJUINF OBUVSFM

Le premier algorithme, naturel, consiste à calculer les puissances
successives de x et d’en former la combinaison linéaire. Autrement
dit la suite (Sk ) définie par :

• S0 = 0
• Sk+1 = Sk + ak ∗ xk
vérifie Sn+1 = P (x).

Fonction E v a l u e r _ p o l y n o m e (A , x )
Donnees :
A : l i s t e de r é e l s ( c o e f f i c i e n t s du polynôme )
x , S, puiss : réels
n , k : entiers ,
Debut
n <−− L o n g u e u r (A)−1 # A = [a0 , a1 , . . . , an ]
p u i s s <−− 1
S <−− 0
Faire
S <−− S + A [ k ] ∗ p u i s s
p u i s s <−− x ∗ p u i s s
Fin F a i r e
Retourner ( S )
Fin
9d
47
Spécification : Cette fonction prend en entrée la liste des coef-
ficients d’un polynôme P rangée suivant les puissances croissantes
et un réel x. Elle renvoie la valeur de P (x).
Terminaison : Il s’agit d’une boucle inconditionnelle. Elle ter-
mine après n + 1 itérations.
Correction : Notons Sk et puissk les valeurs des variables a et
TmBbb à l’issue du k ième passage en boucle. On vérifie qu’un inva-

riant de boucle est ici :
k−1

(Pk ) Sk = A[i] × xi et puissk = xk
i=0
• Initialisation : Avant le premier passage en boucle, S0 est initia-

lisé à 0, ce qui correspond effectivement à la somme sans terme :

−1
A[i] × xi , tandis que puiss0 est initialisé à 1.
i=0
• Hérédité : Soit k 0 tel que (Pk ). Lors du k + 1ième passage en
boucle (qui correspond à l’indice k), a puis TmBb sont actualisés :
k−1

Sk+1 = Sk + A[k] × puissk = A[i]xi + A[k] × xk
i=0
k

= A[i]xi
i=0
puissk+1 = x × puissk = xk+1
Ainsi (Pk+1 ) est vérifié.

• Conclusion : En sortie de boucle, à l’issue du n+1ième et dernier
passage, on a : n

Sn+1 = A[i]xi = P (x).
i=0
Complexité : Le nombre d’OPEL de ce premier algorithme est

de 6n + 11.
93
48
def E v a l u e r _ p o l y n o m e (A , x ) :
n= l e n (A)
p u i s s =1
S=0
S=S+A [ k ] ∗ p u i s s
p u i s s=x ∗ p u i s s
return (S)

-hBMHPSJUINF EF )ÚSOFS
Le deuxième algorithme (dit schéma de Hörner) est basé sur l’idée

que :
P (x) = a0 + x(a1 + x(a2 + · · · x(an−1 + xan ) · · · ))
En d’autres termes, la suite (uk ) définie par :

• u 0 = an
• uk = an−k + xuk−1
vérifie un = P (x).
Fonction Horner_polynome (A , x )
Donnees :
A : l i s t e de r é e l s ( c o e f f i c i e n t s du polynôme )
x , S, puiss : réels
n , k : entiers ,
Debut
n <−− L o n g u e u r (A)−1 # A = [a0 , a1 , . . . , an ]
u <−− A [ n ]
Pour i v a r i a n t de n−1 à 0
Faire
u <−− A [ i ] + x ∗ u
Fin F a i r e
Retourner ( u )
Fin
9N
49
Terminaison : La boucle inconditionnelle s’arrête après n itéra-
tions.
Correction : Notons uk la valeur de la variable informatique m
après k passages en boucle. Un invariant de boucle est :
(Pk ) uk = an−k + an−k+1 x1 + · · · + an xk .
• Initialisation : Avant le premier passage en boucle, on a u0 =

an x0 .
• Hérédité : Soit k tel que Pk est vérifié. À l’issue du k + 1ième
passage en boucle (qui correspond à l’indice i = n − k − 1) on a :
uk+1 = an−k−1 + x × uk

= an−k−1 + x × an−k + an−k+1 x1 + · · · + an xk
= an−k−1 + an−k x1 + an−k+1 x2 + · · · + an xk+1
Ainsi, (Pk+1 ) est bien vérifié.

• Conclusion : En sortie de boucle, après n passages en boucle, on
a bien un = P (x).
Complexité : Le coût de ce deuxième algorithme, s’élève à 4n +
4. En effet, il y a ici 4 opérations dans la boucle.
On peut démontrer que l’algorithme de Hörner est optimal, c’est
l’algorithme d’évaluation d’un polynôme mettant en jeu le moins
d’opérations élémentaires.
def Horner_polynome (A , x ) :
n=l e n (A)−1
u=A [ n ]
f o r i i n r a n g e ( n−1,−1,−1) :
u= A [ i ]+ x ∗u
return (u)
8y
50
1SPHSBNNFS BWFD MFT FOUJFST
%JWJTJPO FVDMJEJFOOF
-hBMHPSJUINF

Fonction D i v i s i o n _ e u c l i d i e n n e ( a , b ) :
Donnees
a , b , q , r , d e s e n t i e r s n a t u r e l s , b>0
Debut
q <−− 0
r <−− a
Tant que r >= b
Faire
q <−− q+1
r <−− r−b
Fin F a i r e
Retourner ( q , r )
Fin

Spécification : Cette fonction prend comme données deux entiers
naturels a et b, avec b > 0 et calcule le quotient et le reste de la
division euclidienne de a par b, c’est-à-dire l’unique couple (q, r)
d’entiers tel que :
• a=b×q+r
• 0r<b
Terminaison de boucle : Notons pour k ∈ N, rk et qk les
valeurs des variables q et r après k passages dans la boucle et Pk
la propriété
(Pk ) rk 0 et a = b × qk + rk .
8R
51
La suite (rk ) est une suite d’entiers naturels strictement décroissante,
elle est donc nécessairement finie. Par conséquent, il existe k tel que
rk < b. On note n le plus petit entier avec cette propriété.
Correction : Une récurrence facile permet de montrer que pour
tout k ∈ [[0, n]] Pk est vraie.
De plus, à l’issue de la boucle, on a à la fois la condition d’arrêt
rn < b et l’invariant Pn , ce qui revient exactement à dire que a =
b × qn + rn et 0 rn < b
Complexité : Le nombre d’opérations élémentaires est de l’ordre
a
de � ab � : N = 3 + 3 × � �.
b
def D i v i s i o n _ e u c l i d i e n n e ( a , b ) :
q=0
r=a
w h i l e r>=b :
q=q+1
r=r−b
return (q , r )
#PÔUF Ë PVUJMT
Lorsque et # sont des entiers, le quotient et le reste de la division

euclidienne de par # s’obtiennent directement en Python :
reste de la division euclidienne
W#
de a par b.
quotient de la division eucli-
ff#
dienne de a par b.
couple quotient,reste de la divi-
divmode(a,b)
sion euclidienne de a par b.
8k
52
5FTU EF QSJNBMJUÏ TJNQMF
-hBMHPSJUINF
Fonction E s t _ p r e m i e r ( n )
Donnees
prem : b o o l é e n
k,n : entiers
Debut
prem <−− V r a i

Pour k v a r i a n t de 2 à n−1
Faire
Si k d i v i s e n
A l o r s prem <−− Faux
Fin S i
Fin F a i r e
Retourner ( prem )
Fin

Spécification : La fonction prend en entrée un entier naturel M
supérieur à 2 et indique en retour o`B s’il est premier, 6mt sinon.
Correction : Notons premk la valeur de la variable T`2K à l’issue
de la boucle d’indice k. Un invariant de boucle est « premk équivaut

à n n’est divisible par aucun entier compris entre 2 et k ».
Complexité : La complexité de cet algorithme est de l’ordre de
3n − 4.
On peut surtout noter le manque d’efficacité de cet algorithme, qui,
pour conclure que n = 1024 n’est pas premier, devra effectuer 3068
OPEL, alors que dès la première itération, il apparaît que n étant pair,
il n’est pas premier !
L’utilisation d’une boucle conditionnelle permet d’améliorer ceci :
Fonction E s t _ p r e m i e r 2 ( n )
Donnees
prem : b o o l é e n
k,n : entiers
8j
53
Debut
k <−− 2
prem <−− V r a i
Tant que ( Prem e s t V r a i et k<n )
Faire
Si k d i v i s e n
A l o r s prem <−− Faux
Fin S i
k <−− k+1
Fin F a i r e
Retourner ( prem )
Fin
def E s t _ p r e m i e r 2 ( n ) :
k=2
prem=True
w h i l e ( prem and k<n ) :
i f n%k == 0 :
prem=F a l s e
k=k+1
r e t u r n ( prem )
On peut également utiliser une boucle conditionnelle en utilisant

l’instruction `2im`M pour interrompre la boucle.
def E s t _ p r e m i e r ( n ) :
for k in range (2 , n) :
i f n%k == 0 :
return ( False )
r e t u r n ( True ) :
%ÏDPNQPTJUJPO QSJNBJSF EhVO FOUJFS
Soit n ∈ N, n 2. Il existe alors des nombres premiers p1 , . . . , pN ,

il existe des entiers naturels non nuls α1 , . . . , αN tels que :
89
54
n = pα1 1 × pα2 2 × · · · × pαNN .
Cette écriture, unique à l’ordre des facteurs près, s’appelle la /û@

+QKTQbBiBQM T`BKB`2 /2 n.
-hBMHPSJUINF
Fonction D e c o m p o s i t i o n _ p r i m a i r e ( n )

Donnees
n, i , r , q : entiers
d i v i s e u r s : l i s t e des d i v i s e u r s premiers
Debut
q <−− n
d i v i s e u r s <−− [ ]
Tant que q > 1
F a i r e # t r o u v e r l e p l u s p e t i t d i v i s e u r de q
i <−− 2
r <−− q % i
Tant que r > 0 et i < q
Faire
i <−− i +1
r <−− q % i
Fin F a i r e
d i v i s e u r s <−− d i v i s e u r s +[ i ]
q <−− q // i
Fin f a i r e
Retourner ( d i v i s e u r s )

Spécification : Cette fonction prend en entrée un entier naturel
n et retourne la liste de ses diviseurs premiers.
Terminaison de boucle : Notons pour k ∈ N, qk les valeurs
de la variable informatique q après k passages dans la boucle princi-
pale. Comme i est initialisé à 2 en début de boucle et est incrémenté à
chaque passage dans la boucle secondaire, cette deuxième boucle se
termine après qk −2 passages au maximum. D’autre part, la valeur de
88
55
[ étant divisée par 2 au minimum à chaque passage en boucle prin-
cipale, on a qk+1 < qk . Cette suite strictement décroissante d’entiers
positifs et donc nécessairement finie.
Correction : Notons diviseursk la valeur de la variable /BpB@
b2m`b après k passages en boucle principale. Notons Pk la propriété
diviseurk est la liste des k plus petits diviseurs premiers de n.
• Initialisation : Avant d’entrer dans la boucle principale, /BpBb2m`b
est la liste vide. Autrement dit, diviseurs0 est la liste des 0 plus
petits diviseurs premiers de n.
• Hérédité : Soit k ∈ N tel que Pk est vraie. Au cours du k + 1ième
passage, on détermine le plus petit diviseur supérieur à 2 de qk .
Comme il est plus petit diviseur de qk , il est nécessairement pre-
mier et il divise n. C’est donc le plus petit diviseur premier de n en
dehors de la liste diviseursk , soit le k + 1ième diviseur premier de n
dans l’ordre croissant. Ainsi, en le rajoutant à la liste diviseursk on
obtient bien la liste des k + 1 plus petits diviseurs premiers de n.
• Conclusion : En sortie de boucle, on a [4R. La liste /BpBb2m`b
contient bien la liste de tous les diviseurs premiers de n rangés dans
l’ordre croissant.
Complexité : La complexité de cet algorithme est un problème
très difficile qui dépasse largement le cadre de cet ouvrage !
def D e c o m p o s i t i o n _ p r i m a i r e ( n ) :
q=n
d i v i s e u r s =[]
w h i l e q>1 :
i =2
r=q%i
w h i l e ( r >0 and i <q ) :
i=i +1
r=q%i
d i v i s e u r s=d i v i s e u r s +[ i ]
q=q // i
return ( d i v i s e u r s )
8e
56
$BMDVM
$BMDVM EV
EV 1($%
1($% EF
EF EFVY
EFVYFOUJFST
FOUJFST
Soit (a, b) ∈∈ N
(a, b) N22.. L’algorithme
L’algorithmed’Euclide
d’Euclidepermet
permetdededéterminer
déterminerle le
plus grand
grand entier,
entier, diviseur
diviseurcommun
communà àaaetetb,b,noté
notéPP
GCD(a,
GCD(a, b).b).Il Il
repose sur
sur le
le fait
faitsuivant
suivant: :
Lemme d’Euclide :: Lorsqu’on
Lemme d’Euclide Lorsqu’oneffectue
effectuelaladivision
divisioneuclidienne
euclidiennedede
a par b,
b, aa =
= bq
bq + avec00rr<<b,b,on
+r,r,avec ona a: :
PPGCD(a,
GCD(a,b)b)==PPGCD(b,
GCD(b,r)r)

On répète
répète ces
ces divisions
divisionssuccessives,
successives,tant
tantque
quelelereste
resteobtenu
obtenuestest
nonnon
nul.
-hBMHPSJUINF
-hBMHPSJUINF
Fonction PGCD(
Fonction PGCD(aa,,bb))
Donnees aa ,,bb,, uu,, vv, , ww : : eennt ti ei er sr s
Donnees
Debut
Debut
u <−−
<−− maxmax((aa,,bb))
v <−−
<−− minmin((aa,,bb))
w <−−
<−− u%vu%v # # rreessttee de
de l al a DE
DE dede u u p p a ra r v v
que ww >
Tant que > 00
FFaaiirree
uu <−−−
<−−− vv
vv <−−−
<−−− ww
w
w <−−−
<−−− u%v u%v # # rreesst tee dede l al a DE DE dede u u p apra rv v
Fin
Fin FFaaiirree
Retourner((vv))
Retourner
Fin
Analyse
Analyse de
de cet
cet algorithme
algorithme: :
Spécification :: La
Spécification fonctionS:*.U-#V
Lafonction S:*.U-#Vprend
prendenenentrée
entréedeux
deux
entiers
entiers
naturels
naturels aa et
et bb et
etretourne
retourneleur
leurPGCD.
PGCD.
Terminaison :: Notons
Terminaison Notonsuukk, ,vvkketetwwk kles
lesvaleurs
valeursdes
desvariables m, m,
variables pp
et r après
après kk passages
passagesdans
danslalaboucle.
boucle.On Ona aparparconstruction
construction: :
8d
8d
57
⎧
⎨ uk = vk−1
v = wk−1 .
⎩ k
wk est le reste de la DE de uk par vk
En particulier wk < wk−1 . La suite (wk ) est une suite strictement

décroissante d’entiers naturels. Elle est donc nécessairement finie.
Correction : Démontrons qu’un invariant de boucle est ici la
propriété :
(Pk ) P GCD(a, b) = P GCD(uk , vk ).
• Initialisation : c’est vrai avant l’entrée dans la boucle.

• Hérédité : Soit k ∈ N tel que Pk . Le lemme d’Euclide montre
que :
P GCD(a, b) = P GCD(uk , vk ) = P GCD(vk , wk )
= P GCD(uk+1 , vk+1 )
• Conclusion : En sortie de boucle, on a wn = 0 et par suite

P GCD(a, b) = P GCD(un , vn ) = P GCD(vn , 0) = vn .
Complexité : Remarquons tout d’abord que wk+2 étant le reste
de la division euclidienne de uk+2 par vk+2 , on a nécessairement

uk+2 vk+2 wk+2 . Il en résulte que uk+2 2wk+2 . Comme
1
uk+2 n’est autre que wk , il s’ensuit que wk+2 < wk . Ainsi w2k <
2
α
2k
, où α = Kt{a, b}. Par conséquent, dès que k HQ;2 (N ),
w2k = 0. Finalement, le nombre de divisions euclidiennes (d’ité-
rations) dans l’algorithme d’Euclide est donc N = HQ;2 (α). Par
suite, la complexité de l’algorithme d’Euclide s’évalue à 4N + 7,
où N = HQ;2 (α).
def PGCD( a , b ) :
i f a>b :
u=a
v=b
83
58
else :
u=b
v=a
w=u%v # r e s t e de l a DE de a p a r b
w h i l e w>0 :
u=v
v=w
w=u%v # r e s t e de l a DE de u p a r v
return ( v )

#PÔUF Ë PVUJMT
fonction du module math qui
gcd(a,b)
retourne le PGCD de et #
$POWFSTJPO EhVO FOUJFS OBUVSFM FO CBTF b
Soit b ∈ N, b 2. Tout entier naturel n ∈ N� peut s’écrire de

manière unique sous la forme :
p
n= ak bk = ap bp + ap−1 bp−1 + · · · + a1 b1 + a0 b0 ,
k=0
où a0 , a1 , . . . , ap ∈ [[0, b − 1]] et ap �= 0. Lorsque b est différent de

10, on notera la base en indice : n = (ap ap−1 . . . a1 a0 )b . Effectuons
la division euclidienne de n par b, il vient :

n = b ap bp−1 + · · · + a1 + a0 .
Ainsi, le reste de la division euclidienne de n par b est a0 et le quo-

tient est le nombre représenté en base b par (ap · · · a1 )b . En itérant ce
procédé, on obtient :
Méthode des divisions euclidiennes successives
On effectue les divisions euclidiennes successives par b jusqu’à l’ob-
tention d’un quotient nul. On note a0 , a1 , . . . , ap−1 , ap les restes
8N
59
obtenus successivement. Alors n admet la représentation en base b :
n = (ap · · · a1 a0 )b
-hBMHPSJUINF
Fonction C o n v e r s i o n ( n , b )
Debut
c h i f f r e s <−− "0123456789ABCDE"
L <−− " " #c h a î n e de c a r a c t è r e v i d e
q <−− n
Tant que q �= 0
Faire
r <−− q%b #r e s t e de l a DE de q p a r b
q <−− q // b #q u o t i e n t de l a DE de q p a r b
L <−− c h i f f r e s [ r ] + L
Fin f a i r e
Retourner ( L )
fin

Spécification : La fonction *QMp2`bBQMUM-#V prend en entrée deux
entiers naturels n 1 et b ∈ [[2, 16]]. Elle retourne en sortie l’écriture
de l’entier n en base b sous la forme d’une chaîne de caractères.
Terminaison : Notons rk , qk et Lk les valeurs des variables `, [
et G après k passages dans la boucle. Lors du k + 1ième passage en
boucle, l’affectation [ IĜ [ff# se traduit par l’égalité qk+1 = qk //b.
En particulier qk+1 < qk . La suite (qk ) est une suite strictement
décroissante d’entiers naturels. Elle est donc nécessairement finie.
Correction : Écrivons n = ap bp +ap−1 bp−1 +· · ·+a1 b1 +a0 b0 .
Notons pour k 0, Pk la propriété :
(Pk ) qk = (ap · · · ak )b et Lk = Ǵak−1 . . . a1 a0 Ǵ.
ey
60
• Initialisation : avant d’entrer en boucle (k = 0), q0 = n =
(ap · · · a0 )b et L est vide.
• Hérédité : Soit k 0 tel que Pk . À l’entrée du k +1ième passage
en boucle, on a
qk = (ap · · · ak )b
Lk = Ǵak−1 . . . a1 a0 Ǵ
On effectue alors la division euclidienne de qk par b : d’après Pk ,

le reste est ak et le quotient est (ap · · · ak+1 )b . Ainsi, à l’issue du
k + 1ième passage, on a
qk+1 = (ap · · · ak+1 )b

Lk+1 = Ǵak Ǵ + Ǵak−1 . . . a1 a0 Ǵ = Ǵak . . . a1 a0 Ǵ
• Conclusion : En sortie de boucle, on a qp+1 = 0 et par suite
Lp+1 = Ǵap . . . a1 a0 Ǵ.
Complexité : Le nombre de passages en boucle est égal à p +

1, c’est-à-dire au nombre de chiffres de l’écriture en base b de n.
Si tel est le cas, cela signifie que l’entier n vérifie l’encadrement
(01p 0 . . . 00 )b n < (1p+1 0 . . . 00 )b , soit :
bp n < bp+1 .
On en déduit successivement
que p HQ;b (n) < p + 1, puis que
HM(n)
p = �HQ;b (n)� = .
HM(b)
Finalement, le nombre d’OPEL dans cet algorithme de conversion
s’évalue à 6p + 10, où p est de l’ordre de HM(n).
def C o n v e r s i o n ( n , b ) :
a s s e r t b <17 , " b d o i t ê t r e i n f é r i e u r à 16 "
c h i f f r e s =" 0123456789ABCDE"
eR
61
L=" " #c h a î n e de c a r a c t è r e v i d e
q=n
w h i l e q !=0 :
r=q%b #r e s t e de l a DE de q p a r b
q=q // b #q u o t i e n t de l a DE de q p a r b
L= c h i f f r e s [ r ]+L
return (L)
#PÔUF Ë PVUJMT
cette fonction prédéfinie re-
bin(n) tourne l’écriture de l’entier M en
binaire
oct(n) tourne l’écriture de l’entier M en
octal
hex(n) tourne l’écriture de l’entier M en
hexadecimal
$POWFSTJPO EF MB CBTF b WFST MB CBTF
Inversement, si n ∈ N est donné par son écriture en base b 2, n =

(ap . . . a1 a0 )b , on peut retrouver son écriture décimale en calculant
la somme :
n = ap bp + ap−1 bp−1 + · · · + a1 b1 + a0 b0 .
-hBMHPSJUINF
Fonction E c r i t u r e _ d e c i m a l e ( L , b )
Données
L : c h a î n e de c a r a c t è r e s
c h i f f r e s : l i s t e de c a r a c t è r e s
b ,B, n , p , k , v a l : e n t i e r s
ek
62
Debut
c h i f f r e s <−−
<−− [[""00"" ,,""11"" ,,""22"" ,,""33"",,""44"", ,""55"", ,""66"", ,""77"", ,""88"", ,

""99"",,"A"
"A",,"B" "B", ,""CC"", ,"D"
"D", ,""EE""] ]
p <−− L o n gguueeuurr ((LL))
B <−−1
n <−− 0
Pour k v a rr ii aa nn tt de de p−1 p−1 àà 00
Faire
#r e c h ee rr cc hheerr LL[[ kk]] dans
d an s lleess cchhi iffffrreess
v a l =0

Tant que que LL [[ kk ]] �= �= cchhiiffffrreess [[ vvaal l]]
F aaiirree
v aa ll <−−
<−− vvaall+1 +1
Fin
Fin ff aaiirree
n <−− nn + + vvaall ∗∗ BB
B <−− bb ∗∗ B B
Fin S i
Fin f aa ii rr ee
Retourner ( nn ))
fin
Analyse de cet
cet algorithme
algorithme ::
Spécification fonction1+`Bim`2n/2+BKH2
La fonction 1+`Bim`2n/2+BKH2prend prendenenentrée
entrée
un entier naturel
naturel bb ∈
∈ [[2, 16]] et
[[2,16]] et une
unechaîne
chaîneLLformée
forméededechiffres
chiffrespour
pour
la base b. Elle retourne
retourne en en sortie
sortie l’entier
l’entier naturel
naturelnnqui
quiaaLLcomme
comme
écriture en base
base b.
b.
Terminaison :: Les
Terminaison Les deux
deux boucles
bouclessont
sontindexées
indexéespar
pardes
desentiers
entierskk
et val qui ne peuvent
peuvent prendre
prendre qu’un
qu’un nombre
nombrefinifinide
devaleurs.
valeurs.Elles
Ellessese
terminent donc.
donc.
Correction :: Notons
Notons pourpour ii 0,
0, nnii lala valeur
valeur de
de lala variable
variable
informatique MM après
après ii passages
passages dans
dans lala boucle
boucle principale.
principale.Un Unin-
in-
variant de boucle
boucle est
est la
la propriété
propriété ::
i−1
i−1
(P
(Pii)) nnii =
= aai−1
i−1 bb +······++aa00bb00. .
+
En sortie de boucle,
boucle, après
après pp passages,
passages, on
onaabien
biennnpp ==aap−1 p−1
p−1bb
p−1++
· · · + a0 b00 = n.
n.
ej
ej
63
Complexité : Le nombre de passages en boucle principale est
égal à p et le nombre d’itérations dans la boucle secondaire est au
maximum égal à b. Ainsi, le nombre d’OPEL dans cet algorithme
s’évalue à 4pb + 5p + 5, où p est la longueur de la liste L.
def E c r i t u r e _ d e c i m a l e ( L , b ) :
c h i f f r e s =[ " 0 " , " 1 " , " 2 " , " 3 " , " 4 " , " 5 " , " 6 " , " 7 " , " 8 " ,

" 9 " , "A" , "B" , "C" , "D" , "E" ]
p=l e n ( L )
B=1
n=0
f o r k i n r a n g e ( p−1,−1,−1) :
v a l =0
w h i l e L [ k ] != c h i f f r e s [ v a l ] :
v a l=v a l +1
n=n+v a l ∗B
B=b∗B
return (n)
#PÔUF Ë PVUJMT
fonction native de P YTHON,
int(ch,b) retourne l’entier représenté en
base # par la chaîne +?.
« Aujourd’hui, la programmation est devenue une course

entre le développeur, qui s’efforce de produire de meilleures
applications à l’épreuve des imbéciles et l’univers, qui s’efforce
de produire de meilleurs imbéciles. Jusque-là, c’est l’univers
qui gagne. »
3JDI $PPL, écrivain américain.
e9
64
3FDIFSDIF EhÏMÏNFOU
EBOT VOF MJTUF
1SÏTFODF EhVO ÏMÏNFOU EBOT VOF MJTUF

La manière la plus simple de rechercher une valeur consiste tout sim-
plement à comparer l’un après l’autre les éléments de la liste avec la
valeur recherchée jusqu’à ce qu’on la trouve.
-hBMHPSJUINF
Fonction A p p a r t i e n t ( a , L )
Donnees
a : valeur recherchée
k, n : entiers
trouve : booléen
Debut
n <−− L o n g u e u r ( L )
t r o u v e <−− f a u x
Faire
Si L [ k ] = a
A l o r s t r o u v e <−− v r a i
Fin S i
Fin F a i r e
Retourner ( t r o u v e )
Fin

Spécification : La fonction TTìB2Mi U-GV prend en argument
un réel a et une liste de réels L. Elle retourne vrai ou faux suivant que
a appartient à L ou pas.
e8
65
Terminaison : La terminaison ne pose ici aucun problème puis-
qu’il s’agit d’une boucle inconditionnelle.
Correction : Un invariant de boucle est ici « Après k passages
dans la boucle i`Qmp2 est vrai si l’élément a a été trouvé et faux sinon
».
Complexité : Pour chaque passage en boucle, il y a un test et
éventuellement une affectation. Compte tenu de l’intialisation et du
retour de résultat, le nombre d’OPEL est donc 3n + 3, où n est la
longueur de la liste.
On peut noter ici que l’efficacité n’est pas optimale puisque si l’élé-
ment a a été trouvé dès le premier élément de la liste, il faudra par-
courir l’ensemble de la liste pour retourner le résultat !
L’utilisation d’une boucle conditionnelle permet de remédier à ce
défaut :
Fonction A p p a r t i e n t 2 ( a , L )
Donnees
k, n : entiers
trouve : booléen
Debut
n <−− L o n g u e u r ( L )
k <−− 0
Tant que k < n et L [ k ] �= a
Faire
k <−− k+1
Fin F a i r e
Si k < n
A l o r s t r o u v e <−− v r a i
Sinon t r o u v e <−− f a u x
Fin S i
Fin
ee
66
def A p p a r t i e n t 2 ( a , L ) :
t r o u v e=F a l s e
n=l e n ( L )
k=0
w h i l e ( k<n and L [ k ] != a ) :
k=k+1
i f k<n :
t r o u v e=True
return ( trouve )

#PÔUF Ë PVUJMT
retourne le booléen égal à True
s in L lorsque l’élément b apparaît dans
la liste G
3FDIFSDIF EJDIPUPNJRVF EhVO ÏMÏNFOU
Étant donné une liste L de n réels, nous avons déjà obtenu un algo-
rithme pour rechercher la présence d’un élément a dans cette liste.
Cet algorithme séquentiel avait une complexité linéaire en n. Lorsque
la liste est triée par ordre croissant, nous pouvons faire bien mieux !
-hBMHPSJUINF
Fonction A p p a r t i e n t 3 ( a , L )
Donnees
L : l i s t e t r i e e par ordre c r o i s s a n t
N,m, g , d : e n t i e r s
a : réel recherché
trouve : booléen
Debut
n <−− L o n g u e u r ( L )
I m i n <−−0
ed
67
Imax
Imax <−−n−1
<−−n−1
Tant que IImmi ni n <=
Tant que <= Imax Imax etetNon Non( t(r toruovuev)e )
FFaaiirree
mm <−−(I
<−−(Immi n+Imax i n+Imax)//2 ) / / 2##mme sets tl e l ep l pu sl u sgd gde n et inetri e r

i innf féér ri ieeuur r auau mm i l i leiue u e netnr ter eI mIimn i net etImax
Imax
SSii LL[m][m] == aa
AAl loorrss t tr roouuv ve e<−−<−−v rvar ia i
Sinon SSi i LL[m]
Sinon [m]<<a aA A l olrosr sI mI im
n i n<−−
<−− m+1m+1
Sinon SSi i LL[m]
Sinon [m]>>a aA A l olrosr sImax
Imax <−−
<−− m−1m−1
Fin
Fin SSi i
Fin
Fin FFaai irree
Retourner ((ttr roouuvve e) )
Retourner
Fin
Fin
Analyse
Analyse de
de cet
cetalgorithme
algorithme: :
Spécification: : La
Spécification fonctionTTìB2MijU-GV
Lafonction TTìB2MijU-GV prend
prend
en en
argument
argument
un réel
réel aaetetune
uneliste
listede
deréels
réelsL.L.Elle
Elleretourne
retourne
vrai
vrai
ouou
faux
faux
suivant
suivant
queque
a appartient
appartientààLLou oupas.
pas.
Terminaison: : Notons
Terminaison Notonspour
pourk k∈ ∈N,N,mmk , kImin
, Imin
k et et Imax
k Imax k les
k les
valeurs
valeurs des
desvariables
variablesm, IminetetImax
m,Imin Imax à l’issue
à l’issue k ième
dudu k ième
passage
passage
en en
boucle.
boucle. On
Onaapour
pourtout
toutentier
entierk kque
que
Imin
Imin k kmmk kImax
Imax k k
De plus,
plus,la
lasuite
suite(Imin
(Imink k) )est
estcroissante,
croissante,la la
suite
suite
(Imax k ) est
(Imax k ) est
décroissante.
décroissante.
Comme
Comme

k+12 2Imax
1 1
Imax
Imaxk+1k+1−−Imin
Imin k+1 Imax k−k−Imin k ,k ,
Imin
il en
en résulte
résulte que
queces
cesdeux
deuxsuites
suitesd’entiers
d’entiersnaturels
naturels
sont
sont
donc
donc
adja-
adja-
centes
centes et
et par
parconséquent
conséquentfinies.
finies.
Correction :: Un
Correction Uninvariant
invariantdedeboucle
boucleestest
iciici
« Après
« Après k passages
k passages
dans
dans la boucle i`Qmp2
la boucle i`Qmp2est
estfaux
fauxououa aappartient
appartientà la à la
sous-liste
sous-liste
desdes
termes
termes d’indices
d’indicescompris
comprisentre
entreImin
Imin k et
k et
Imax
Imaxk. k».. ».
Complexité : :Comme
Complexité Commelalalongueur
longueurdedela laliste
liste
dans
dans
laquelle
laquelle
on on
effectue
effectue lala recherche
rechercheest
estdivisée
diviséepar
par2 2à àchaque
chaque nouvelle
nouvelle
étape,
étape,
on on
a après
après kk étapes
étapes nn
Imax
Imax k k−−Imin
Imink k k .k .
22
e3e3
68
Par suite, si k HQ;2 (n), on a Imaxk − Imink 1. On effec-
tuera donc au maximum une étape supplémentaire. Finalement, la
complexité de cet algorithme est donc de l’ordre de HM(n), soit bien
meilleure que les algorithmes de recherche séquentielle étudiés pré-
cédemment.
def A p p a r t i e n t 3 ( a , L ) :
t r o u v e=F a l s e

n=l e n ( L )
i m i n=0
imax=n−1
w h i l e ( i m i n<=imax and not ( t r o u v e ) ) :
m=( i m i n+imax ) / / 2
i f L [m]==a :
t r o u v e=True
e l i f L [m]<a :
i m i n=m+1
e l i f L [m]>a :
imax=m−1
return ( trouve )
1SFNJÒSF PDDVSSFODF EhVO ÏMÏNFOU
Un élément, présent au sein d’une liste peut y figurer à plusieurs

reprises. On peut alors s’intéresser au rang d’apparition d’un élément
pour la première fois, ce que l’on appelle la première occurrence d’un
élément.
-hBMHPSJUINF
Fonction P r e m i e r e _ o c c u r r e n c e ( a , L )
Donnees
k, n : entiers
eN
69
Debut
n <−− Longueur
L o n g u e u r ((LL))
k <−− 00
que kk <
Tant que < nn et et LL[[kk] ] �=�= aa
F aaiirree
k <−−
<−− k+1 k+1
Fin
Fin FFaaiirree
Si k << nn
A Retourner ((kk))
Alloorrss Retourner
Sinon Retourner ((Néant
Sinon Retourner Néant) )
Fin S ii
Fin
Analyse
Analyse de de cet
cet algorithme
algorithme ::
Spécification :: En
Spécification entrée,S`2KB2`2nQ++m``2M+2U-GV
Enentrée, S`2KB2`2nQ++m``2M+2U-GVprend prendunun
réel a et
et une
une liste
liste dede réels
réelsL.
L.Elle
Elleretourne
retourneleleplus
pluspetit indiceF Fteltel
petitindice
que L[k] = aa sisi aa appartient
L[k] = appartientààLLou ourien
riensinon.
sinon.
Terminaison :: L’algorithme
Terminaison L’algorithmesesetermine aprèsMMpassages
termineaprès passagesenenboucles
boucles
au maximum.
maximum.
Correction :: Un
Correction Uninvariant
invariantde
deboucle
boucleestest««Après
Aprèsk kpassages
passagesdansdans
la boucle,
boucle, l’élément
l’élémentaan’a n’apas
pasencore
encoreétéététrouvé
trouvé».».
Complexité :: Pour
Complexité Pour chaque
chaquepassage
passageen enboucle,
boucle,ilily ya adeux
deuxtests,
tests,
une affectation
affectation et et une
une addition.
addition.Compte
Comptetenu tenudedel’intialisation
l’intialisationetetdudu
retour de
de résultat,
résultat, lele nombre
nombred’OPEL
d’OPELest estdonc
donc4n 4n++4,4,oùoùn nestestlala
longueur
longueur dede la
la liste.
liste.
-F
-F QSPHSBNNF
QSPHSBNNFFO
FO1ZUIPO
1ZUIPO
def P rreem miieerree__ooccccuurrrreennccee((aa, ,LL) ): :
n=l
n=leenn ((LL))
k=0
k=0
whhiillee ((k<n
w k<n andand LL[ [kk] ] != != aa) ): :
k=k+1
k=k+1
i ff k<nk<n ::
rreettuurrnn ((kk))
e ll ssee ::
rreettuurrnn((None
None))
dy
dy
70
/PNCSF EhPDDVSSFODFT EhVO ÏMÏNFOU
Un élément a, présent au sein d’une liste L, peut y figurer à plusieurs

reprises. On va déterminer le nombre d’apparitions d’un élément.
-hBMHPSJUINF
Fonction Nombre_occurrence ( a , L )
Donnees

a : valeur r é e l l e recherchée
k , n , occur : e n t i e r s
Debut
n <−− L o n g u e u r ( L )
o c c u r <−− 0
Faire
S i L [ k ]= a
A l o r s o c c u r <−− o c c u r + 1
Fin S i
Fin F a i r e
Retourner ( o c c u r )
Fin

Spécification : Cette fonction prend en entrée une liste L de
nombres réels, a un nombre réel et retourne le nombre d’occurrences
de a dans L.
Terminaison : Cette boucle inconditionnelle se termine après n
itérations.
Correction : Notons (occurk ) la suite des valeurs de la variable
informatique Q++m`. Ainsi, pour tout entier k ∈ N, occurk est la
valeur de Q++m` lors de l’entrée en boucle d’indice k. Un invariant de
boucle est ici la propriété (Pk ) :
« occurk est le nombre d’occurrences de a dans

{L[0], . . . , L[k − 1]}».
dR
71
• Initialisation : Lorsque k = 0, occur0 est initialisé à 0, ce qui
correspond bien évidemment au nombre d’apparitions de a dans la
liste vide.
• Hérédité : Soit k 0 tel que Pk . Dans la boucle d’indice k, on
teste si L[k] est égal à a. Si tel est le cas, alors l’affectation Q++m` IĜ
Q++m` Y R se traduit par occurk+1 = occurk + 1. Ainsi, occurk+1
est le nombre d’occurrences de a dans {L[0], . . . , L[k]}.
• Conclusion : Lorsqu’on sort définitivement de la boucle, occurn
est le nombre d’occurrences de a dans {L[0], . . . , L[n − 1]}.
Complexité : Pour chaque passage en boucle, il y a 4 OPEL.
Compte tenu de l’intialisation et du retour de résultat, le nombre

d’OPEL est donc 4n + 3.
def Nombre_occurrence ( a , L ) :
o c c u r= 0
n=l e n ( L )
i f L [ k]==a :
o c c u r=o c c u r +1
return ( occur )
«L’homme est encore le plus extraordinaire des ordinateurs. »
+PIO ' ,FOOFEZ, Ancien président des États-Unis.
dk
72
4UBUJTUJRVFT TVS VOF MJTUF EF SÏFMT
.BYJNVN EhVOF MJTUF
On suppose que nous disposons d’une liste de M nombres réels. Pour

déterminer le maximum de tous les éléments, on introduit une variable
qui prend la valeur maximale des premiers éléments. Nous rédigeons
cet algorithme sous la forme d’une fonction, nommée JtBKmKUGV :
-hBMHPSJUINF
Fonction Maximum ( L )
Donnees
L : une l i s t e de r é e l s
k , n : des e n t i e r s
max : un r é e l
Debut
maxi <−− L [ 0 ]
n <−− L o n g u e u r ( L )
Faire
S i L [ k ] > maxi
A l o r s maxi <−− L [ k ]
Fin S i
Fin F a i r e
Retourner ( maxi )
Fin

Spécification : Cette fonction prend en entrée une liste L de n
nombres réels et retourne la valeur maximale de cette liste.
Terminaison : La terminaison ne pose ici aucun problème car
nous avons une boucle inconditionnelle. La boucle s’arrête après n
dj
73
itérations.
Correction : Notons pour tout entier k ∈ N, mk la valeur de la
variable informatique KtB à l’entrée du passage en boucle d’indice
k (c’est donc le k + 1ième passage) et notons
(Pk ) la propriété : mk−1 = Kt{L[0], . . . , L[k − 1]}
• Initialisation : KtB est initialisé à G(y). Donc m0 = L[0], P1

est vérifié.
• Hérédité : Soit k 1 tel que Pk est vraie :
mk−1 = Kt{L[0], . . . , L[k − 1]}.
En ce cas, si L[k] est strictement supérieur à KtB, on remplace la

valeur de KtB par celle de G(F), sinon, on ne fait rien. Ainsi, à l’issue
du k + 1ième passage en boucle, on aura bien :
mk = Kt{L[0], . . . , L[k]}.
• Conclusion : Lorsque l’algorithme se termine, la propriété P

est vraie pour F4M@R, la valeur KtB coïncide avec le maximum
Kt{L[0], . . . , L[n − 1]}.
Compte tenu de l’intialisation et du retour de résultat, le nombre
d’OPEL est donc 3n + 2.
def Maximum ( L ) :
n=l e n ( L )
maxi=L [ 0 ]
i f L [ k]> maxi :
maxi=L [ k ]
r e t u r n ( maxi )
d9
74
#PÔUF Ë PVUJMT
retourne le maximum d’une liste
max(L)
de réels
retourne le minimum d’une liste
min(L)
de réels
.PZFOOF EhVOF MJTUF

Étant donné une liste de n nombres réels, on peut condenser l’infor-
mation en remplaçant cette série de n nombres par sa valeur moyenne.
Soit (xi )i∈[[0,n−1]] une liste de réels. La valeur moyenne de la liste
(xi ) est donnée par :
n−1
1
m= xi
n
i=0
-hBMHPSJUINF
Fonction Valeur_moyenne ( L )
Donnees
L : une l i s t e de r é e l s
k , n : des e n t i e r s
somme : un r é e l
Debut
n <−− l o n g u e u r ( L )
somme <−− 0
Faire
somme <−− somme + L [ k ]
Fin F a i r e
Retourner ( somme/n )
Fin
d8
75
Spécification : Cette fonction prend en entrée une liste G de M
nombres réels et retourne la valeur moyenne de cette liste.
Terminaison : La terminaison ne pose ici aucun problème car
nous sommes en présence d’une boucle inconditionnelle. La boucle
s’arrête après M itérations.
Correction : Notons pour tout k ∈ N, sommek la valeur de
la variable bQKK2 à l’entrée de la boucle d’indice k (le k + 1ième
passage) et notons
Pk la propriété : sommek = L[0] + · · · + L[k − 1]
• Initialisation : Avant le premier passage en boucle, bQKK2 est

initialisé à 0, ce qui revient à dire que somme0 = 0.
• Hérédité : Soit k 0 et supposons que
sommek = L[0] + · · · + L[k − 1].
En ce cas, lors du k + 1ième passage, l’affectation

bQKK2 IĜ bQKK2 Y G(F)
se traduit par
sommek+1 = sommek + L[k]

= L[0] + · · · + L[k − 1] + L[k].
• Conclusion : Lorsque l’algorithme se termine, la propriété P est

vraie pour F4M@R, c’est-à-dire la valeur bQKK2 est égale à la somme
L[0] + · · · + L[n − 1]. En divisant ce nombre par n, on obtient bien
la valeur moyenne de cette liste.
Compte tenu de l’initialisation, du calcul et du retour de résultat,
le nombre d’OPEL est donc 3n + 4.
de
76
-F
-F QSPHSBNNF
QSPHSBNNF FO 1ZUIPO
def Moyenne
def Moyenne((LL)) ::
n=l
n=leenn((LL))
somme=0
somme=0
ffoorr kk iinn rraannggee (( nn ) :
somme
somme = = somme
somme + L [ k ]
rreettuurrnn((somme/n
somme/n))
#PÔUF Ë PVUJMT

UMPY,, retourne
fonction de N UMPY retourne lala
mean(L)
mean(L)
valeur moyenne
moyenne d’une
d’une liste
liste
7BSJBODF
7BSJBODF EhVOF
EhVOF MJTUF
MJTUF
On
Onpeut
peutdonc
donc représenter
représenter une
une distribution de valeurs
valeurs par
par sa
sa moyenne
moyenne
en
enpremière
premièreapproximation.
approximation. Ce faisant, on commet bienbien entendu
entendu une
une
erreur.
erreur.La
Lavariance
variance mesure
mesure précisément la dispersion
dispersion des
des valeurs
valeurs au-
au-
tour
tourde
delalamoyenne.
moyenne. C’est
C’est donc
donc une mesure d’erreur.
d’erreur.
Soit
Soit (x(xii))i∈[
i∈[[0,n−1]] une
[0,n−1]] une liste
liste de moyenne m. La variance
variance de
de la
la liste
liste
(xii))est
(x estdonnée
donnée parpar deux
deux expressions
expressions :
Formule
Formule de
de Huygens
Huygens ::
n−1
n−1 n−1
11
1 2
VV =
= (xii − m)2 =
(x m22
xi − m
nn n
i=0
i=0 i=0
Remarque :: en
Remarque en pratique,
pratique, on préfère utiliser la deuxième
deuxième expres-
expres-
sion.
sion.C’est
C’estégalement
également ce
ce point
point de vue que nous utiliserons.
utiliserons.
-hBMHPSJUINF
Fonction VVaarriiaannccee ((LL))
Fonction
Donnees
Donnees
dd
77
L : ll ii ss tt ee de
de rrééeel lss
k , n :: eennttiieerrss
smoy ,, ssvvaarr :: rrééeel lss
Debut
Debut
n <−−
<−− Longueur
L o n g u e u r((LL))
smoy <−− <−− 00
s v a r <−−
<−− 00
Pour kk vvaarriiaanntt de de 00 àà n−1
n−1
FFaaiirree
smoy
smoy <−− <−− smoysmoy ++ LL[ [kk] ]
ss vvaarr <−−
<−− ssvvaarr ++ LL[ [kk] ∗] ∗LL[ k[ k] ]
Fin
Fin FFaaiirree
Retourner (( ((ssvvaarr/n
Retourner /n)) −− ( (smoy/n
smoy /n) ∗) ∗( smoy/n
( smoy /n
) )) )
Fin
Analyse
Analyse de de cet
cet algorithme
algorithme: :
Spécification :: Cette
Spécification Cettefonction
fonctionprend
prendenenentrée
entréeune uneliste
listeL Ldedenn
nombres
nombres réels
réels et
etretourne
retournelalavariance
variancededecettecetteliste.
liste.
Terminaison :: La
Terminaison La terminaison
terminaisonnenepose poseiciiciaucun
aucunproblème
problèmecarcar
nous avons
avons une
une boucle
boucleinconditionnelle.
inconditionnelle.La Laboucle
boucles’arrête
s’arrêteaprès
après MM
itérations.
itérations.
Correction :: Notons
Correction Notonspourpourtout
toutkk∈∈N,N,smoy smoy k k(resp
(respsvar
svark )kla
) la
valeur de
de la variablebKQv
la variable bKQv(resp
(respbp`)
bp`)à àl’entrée
l’entréededelalaboucle
boucle d’indice
d’indice
k (soit
(soit également
également àà l’issue
l’issuedu dukkième
ièmepassage
passageenenboucle).
boucle).OnOndéfinitdéfinit
Pk la propriété
propriété ::
smoy
smoykk =
= L[0]
L[0]+ L[k] etet svar
+······++L[k] svar
k k==L[0]
L[0]22
++· ····+
·+L[k]
L[k]2 2
Initialisation :: Lors
• Initialisation Lorsdu
dupassage
passagedans
danslalaboucle
boucled’indice
d’indice0,0,
somme
somme 0 0
vaut 0.
0.
Hérédité :: Soit
• Hérédité Soitkk 00etetsupposons
supposonsque
quePP k kest
estvraie.
vraie.EnEncece
cas,
cas,
lors du + 11ième
du kk + ième passage,
passage,
smoy
smoyk+1
k+1 =
= smoy
smoykk++L[k
L[k++1]1]
L[0]++· · · ·++L[k]
== L[0] L[k++1]1]etet
L[k]++L[k
22
svar
svark+1
k+1 =
= svar
svarkk++L[k
L[k++1]1]
L[0]22++· · · ·++L[k]
== L[0] L[k]22
++L[k 2 2
L[k++1]1]
d3
d3
78
vraie pour F4M, ie. la valeur bKQv est égale à la somme L[1] + · · · +
L[n] et la valeur de bp` est égale à la somme L[0]2 + · · · + L[n]2 . À
l’aide de la Formule de Huygens, on en déduit la variance.
Compte tenu de l’intialisation et du calcul et du retour de résultat,

le nombre d’OPEL est donc 6n + 10.

def V a r i a n c e ( L ) :
n=l e n ( L )
smoy=0
s v a r =0
smoy = smoy + L [ k ]
s v a r=s v a r+L [ k ] ∗ ∗ 2
r e t u r n ( s v a r /n−(smoy /n ) ∗ ∗ 2 )
#PÔUF Ë PVUJMT
fonction de N UMPY qui retourne
var(L)
la variance d’une liste
celle-ci retourne l’écart-type (ra-
std(L)
cine carrée de la variance)
.ÏEJBOF EhVOF MJTUF
Étant donné une liste de n nombres réels distincts, la médiane est la

valeur qui partage en deux l’effectif de la liste.
Lorsque (xi )i∈[[0,n−1]] une liste strictement croissante de réels. La
valeur médiane de la liste (xi ) est donnée par :

− xp , si n = 2p + 1 est un nombre impair
− 12 (xp−1 + xp ) , si n = 2p est un nombre pair.
dN
79
L’algorithme qui suit calcule la médiane d’une liste qui n’est pas
nécessairement triée.
-hBMHPSJUINF
Fonction Mediane ( L )
LP <−− L
LG <−− [ ] #L i s t e v i d e
Tant que L o n g u e u r ( LP)− L o n g u e u r ( LG ) > 0
F a i r e #t r o u v e r l ‘ i n d i c e du maximum de LP
imax=0
Pour k v a r i a n t de 0 à L o n g u e u r ( LP)−1
Faire
S i LP [ k ] > LP [ imax ]
A l o r s imax <−− k
Fin S i
Fin F a i r e
#E n l e v e r l e t e r m e LP [ imax ] de LP
LP <−− LP \ LP [ imax ]
#R a j o u t e r l e t e r m e LP [ imax ] à LG
LG <−− LG + LP [ imax ]
Fin F a i r e
S i L o n g u e u r ( LP ) = L o n g u e u r ( LG )
A l o r s Retourner ( Maximum ( LP)+LG [ 0 ] ) ∗ 0 . 5 )
Sinon Retourner ( LG [ 0 ] )
Fin S i
Fin

Spécification : Cette fonction prend en entrée une liste G de M
nombres réels distincts et retourne la valeur médiane de cette liste.
Terminaison : À chaque passage dans la boucle conditionnelle,
on enlève un terme de la liste GS pour l’ajouter à la listeG:. Ainsi, la
différence GQM;m2mÙGSV@GQM;m2mÙG:V diminue de 2. Les valeurs
successives de cette expression forment donc une suite strictement
décroissante d’entiers strictement positifs. Elle est donc nécessaire-
ment finie.
3y
80
Correction : Notons pour tout i ∈ N, LGi et LPi les valeurs des
variables GS et G: à l’entrée du i + 1ième passage) dans la boucle
inconditionnelle. Notons Pi la propriété :
LGi est la suite ordonnée des i plus grandes valeurs de L
• Initialisation : Avant le premier passage en boucle, G: est vide,

elle est formée des 0 plus grandes valeurs de la suite G.
• Hérédité : Soit i 0 et supposons que Pi est vérifié. En ce cas,

lors du i + 1ième passage, on repère la valeur maximale de LPi , on
l’enlève et on la rajoute à LGi (par la gauche). Ainsi, LGi+1 est bien
constituée des i + 1 plus grandes valeurs de L et elle est rangée par
ordre croissant.
vraie. En outre, Longueur(LPi ) − Longueur(LGi ) 0. Compte
tenu du fait que cette suite décroît de 2 en 2, il y a possibilités :
Lorsque Longueur(LPi ) − Longueur(LGi ) = −1, c’est-à-
dire lorsque Longueur(LGi ) = Longueur(LPi ) + 1. En ce
cas, la médiane est la plus petite valeur de LGi .
Lorsque Longueur(LPi ) − Longueur(LGi ) = 0, c’est-à-dire
lorsque Longueur(LGi ) = Longueur(LPi ). En ce cas, la mé-
diane est la moyenne entre la plus petite valeur de LGi et la plus
grande valeur de LPi .
Complexité : La boucle inconditionnelle peut être indexée par
GQM;m2mÙGSV qui diminue de n à n2 à pas de 1. À chaque passage

dans cette boucle, on réalise un parcours de la liste GS. Ainsi, la
complexité de cet algorithme est de l’ordre de n2 .
Remarque : l’utilisation d’algorithme de tri ou de la récursivité
permet d’améliorer grandement cet algorithme. Voir l’algorithme de
recherche rapide de la médiane, page 141.
def Mediane ( L ) :
LP=L ; LG = [ ]
3R
81
w h i l e l e n ( LP)− l e n ( LG)>0 :
imax=0
f o r k i n r a n g e ( l e n ( LP ) ) :
i f LP [ k]>LP [ imax ] :
imax=k
LG=[LP [ imax ] ] + LG
LP=LP [ : imax ]+LP [ imax +1 :]
i f l e n ( LP)− l e n ( LG)==0 :
r e t u r n ( ( Maximum ( LP)+LG [ 0 ] ) ∗ 0 . 5 )
e l i f l e n ( LP)− l e n ( LG ) == −1 :
r e t u r n ( LG [ 0 ] )
#PÔUF Ë PVUJMT
fonction de N UMPY retourne la
median(a) valeur médiane d’une liste de
réels
« En mathématiques, on ne comprend pas les choses, on s’y

habitue. »
+PIO 7PO /FVNBOO, mathématicien américain.
3k
82
3FDIFSDIF EhVOF TPVTTÏRVFODF
3FDIFSDIF EhVOF TÏRVFODF EBOT VOF MJTUF
Nous allons écrire un algorithme qui détecte la présence d’une sé-

quence a0 , a1 , . . . , ar−1 de r réels dans une liste (principale) de n
réels L0 , L1 , . . . , Ln−1 .
Pour ce faire, l’algorithme parcourt séquentiellement la liste L et
compte, à partir de la position courante dans la liste L, j, le nombre
de termes consécutifs qui coïncident dans les deux listes. Ce nombre
de succès consécutifs est stocké dans une variable dénommée F. Si k
atteint la longueur totale de la séquence a, c’est que toute la séquence
apparaît dans la liste L.
-hBMHPSJUINF
Fonction Contenu ( a , L )
Donnees
a , L : l i s t e s de r é e l s
j , k, r , n : entiers
trouve : booléen
Debut
n <−− L o n g u e u r ( L )
r <−− L o n g u e u r ( a )
Pour j v a r i a n t de 0 à n − r
Faire
k <−− 0
Tant que k < r et a [ k ] = L [ j+k ]
Faire
k <−− k + 1
Fin F a i r e
Si k = r
A l o r s t r o u v e <−− V r a i
3j
83
Fin S i
Fin F a i r e
Fin

Spécification : Cette fonction prend en argument deux listes de
réels, a et L de longueurs respectives r et n. Elle retourne vrai ou
faux suivant que la séquence a apparaît dans la liste L ou pas.
Terminaison : Pour j compris entre 0 et n − r − 1, la boucle
conditionnelle se termine après r itérations au maximum. La boucle
inconditionnelle se termine quant à elle après n − r itérations.
Correction : Pour j compris entre 0 et n − r − 1, notons succesj
la valeur de la variable informatique F à la fin du j + 1ième passage
dans la boucle inconditionnelle.
Un invariant de cette boucle est :
« Pj succesj est égal au nombre de coïncidences consécutives entre
entre les termes de la liste L à partir du rang j et la séquence a ».
Lorsque succesj est égal à r, cela signifie que (Lj , . . . , Lj+r−1 )
coïncide avec (a0 , a1 , . . . , ar−1 ). La séquence a a été détectée.
Complexité : Pour chaque passage en boucle conditionnelle, il
y a 4 OPEL (deux comparaisons, une addition et une affectation).

Ainsi, chaque passage en boucle inconditionnelle représente au maxi-
mum 4r + 3 OPEL. Finalement, compte tenu des initialisations et du
retour du résultat, le nombre maximal d’OPEL est (n − r + 1)(4r +
3) + 4, où n et r sont les longueurs des deux listes.
def Contenu ( a , L ) :
n=l e n ( L )
r=l e n ( a )
trouve = False
f o r j i n r a n g e ( n−r +1) :
k=0
39
84
w h i l e ( k<r and a [ k]==L [ j+k ] ) :
k=k+1
i f k==r :
t r o u v e = True
return ( trouve )
Remarque : On peut améliorer l’efficacité de cet algorithme en

quittant la boucle inconditionnelle dès que la séquence a a été détectée.
def Contenu2 ( a , L ) :

n=l e n ( L )
r=l e n ( a )
f o r j i n r a n g e ( n−r +1) :
k=0
w h i l e ( k<r and a [ k]==L [ j+k ] ) :
k=k+1
i f k==r :
r e t u r n ( True )
return ( False )
1SÏTFODF EhVO NPU EBOT VOF DIBÔOF
L’algorithme précédent s’applique également aux chaînes de carac-

tères. Il s’agit alors de détecter la présence d’un mot dans un texte.
-hBMHPSJUINF
Fonction R e c h e r c h e ( mot , t e x t e )
Donnees
t e x t e , mot : c h a î n e s de c a r a c t è r e s ,
j , k, r , n : entiers
trouve : booléen
Debut
n <−− L o n g u e u r ( t e x t e )
r <−− L o n g u e u r ( mot )
Pour j v a r i a n t de 0 à n − r
38
85
Faire
k <−− 0
Tant que k < r et mot [ k ] = t e x t e [ j+k ]
Faire
k <−− k+1
Fin F a i r e
Si k = r
A l o r s t r o u v e <−− V r a i
Fin S i
Fin F a i r e
Fin

Spécification : La fonction _2+?2`+?2 UKQi - i2ti2V prend en
argument deux chaînes de caractères, KQi et i2ti2. Elle retourne
vrai ou faux suivant que la chaîne de caractères KQi apparaît dans
la chaîne i2ti2 ou pas.
Terminaison : Pour j compris entre 0 et n − r − 1, la boucle
conditionnelle se termine après r itérations au maximum. La boucle
inconditionnelle se termine quant à elle après n − r itérations.
Correction : Pour j compris entre 0 et n − r − 1, notons succesj
la valeur de la variable informatique F à la fin du j + 1ième passage
dans la boucle inconditionnelle.
Un invariant de cette boucle est :
« Pj succesj est égal au nombre de coïncidences consécutives entre
entre les caractères de la chaîne i2ti2 à partir du rang j et la chaîne
KQi ».
Lorsque succesj est égal à r, cela signifie que KQi apparaît dans la
chaîne i2ti2.
Complexité : Pour chaque passage en boucle conditionnelle, il
y a 4 OPEL (deux comparaisons, une addition et une affectation).

Ainsi, chaque passage en boucle inconditionnelle représente au maxi-
mum 4r + 3 OPEL. Finalement, compte tenu des initialisations et du
3e
86
retour du résultat, le nombre maximal d’opérations élémentaires est
(n − r + 1)(4r + 3) + 4, où n et r sont les longueurs des deux listes.
def R e c h e r c h e r ( mot , t e x t e ) :
n=l e n ( t e x t e )
r=l e n ( mot )
trouve = False
f o r j i n r a n g e ( n−r +1) :

k=0
w h i l e ( k<r and mot [ k]== t e x t e [ j+k ] ) :
k=k+1
i f k==r :
t r o u v e = True
return ( trouve )
Remarque : On peut améliorer l’efficacité de ce programme en

quittant la boucle inconditionnelle dès que la chaîne KQi est détec-
tée.
def R e c h e r c h e r ( mot , t e x t e ) :
n=l e n ( t e x t e )
r=l e n ( mot )
f o r j i n r a n g e ( n−r +1) :
k=0
w h i l e ( k<r and mot [ k]== t e x t e [ j+k ] ) :
k=k+1
i f k==r :
r e t u r n ( True )
return ( False )
#PÔUF Ë PVUJMT
retourne directement le booléen
mot in texte qui est vrai lorsque KQi apparaît
comme sous-chaîne de i2ti2
3d
87
1SPHSBNNFS BWFD MFT TVJUFT
FU MFT GPODUJPOT
4VJUF SÏDVSSFOUF un+1 = f (un )
Soit f : I → I une fonction définie et à valeurs dans un intervalle

I de R et a ∈ I. Il existe une suite (un )n∈N unique définie par les
relations :
• u0 = a
(S)
• ∀k ∈ N, un+1 = f (un )
De nombreuses méthodes d’approximations numériques reviennent
à déterminer le terme de rang n d’une telle suite.
-hBMHPSJUINF
Fonction S u i t e _ r e c u r r e n t e ( f , a , n )
Donnees
f : fonction
a,u : reels
n,k : entiers
Debut
u <−− a
Faire
u <−− f ( u )
Fin F a i r e
Retourner ( u )
Fin

Spécification : La fonction amBi2n`2+m``2Mi2 prend en en-
trée une fonction itératrice 7, une valeur initiale et un entier M et
33
88
retourne en sortie la valeur du terme de rang n de la suite (un ).
Terminaison : La terminaison de cette boucle inconditionnelle
ne pose pas de problème.
Correction : Un invariant de boucle est ici « La valeur de la
variable m après k passages en boucle est le terme de rang k de
la suite définie par (S). »
Complexité : Évaluer le nombre d’opérations élémentaires d’un
tel algorithme suppose de connaître la complexité de l’évaluation de

f en u. En supposant que celle-ci est d’une OPEL, la complexité de
l’algorithme s’évalue à 3n + 2 OPEL.
def S u i t e _ r e c u r r e n t e ( f , a , n ) :
u=a
u=f ( u )
return (u)
Pour l’étude de la limite d’une telle suite, voir la Kûi?Q/2 /m

TQBMi }t2, p 97.
4VJUF SÏDVSSFOUF un+2 = f (un+1 , un )
Il arrive qu’une suite soit définie par une relation de récurrence met-
tant en jeu trois générations de termes. En ce cas, il est nécessaire de
connaître deux valeurs initiales pour la déterminer. Le schéma est le
suivant :

• u0 = a, u1 = b
(S2 )
• ∀k ∈ N, un+2 = f (un+1 , un )
3N
89
-hBMHPSJUINF
-hBMHPSJUINF
Fonction SSuuiittee__rreeccuurrrreennttee22((f f, ,aa, ,bb, ,nn) )
Fonction
Donnees
f : f o n ccttiioonn
a , b , u , v ,,ww :: rrééeellss
n , k : e nn tt ii ee rrss
Debut
u <−− b
v <−− a
Pour k vv aa rriiaanntt de de 00 àà n−1
n−1
F a i rree
w <−−
<−− ff ((uu ,, vv))
v <−−
<−− uu
u <−−
<−− w w
Fin FFaaiirree
Retourner (( vv))
Retourner
Fin
Analyse de
de cet
cet algorithme
algorithme ::
Spécification fonctionamBi2n`2++m`2Mi2k
Lafonction amBi2n`2++m`2Mi2kprend prendenenentrée
entrée
une fonction itératrice7,
fonction itératrice 7,deux
deuxvaleurs initiales,,##etetun
valeursinitiales entierM.M.Elle
unentier Elle
retourne en
en sortie
sortie la
lavaleur
valeurdu
duterme
termede
derang
rangnndedelalasuite
suiteààrécurrence
récurrence
d’ordre 2, (u
(unn).).
Terminaison :: La
terminaison de
de cette
cetteboucle
boucleinconditionnelle
inconditionnelle
ne pose pas
pas de
de problème.
problème.
Correction :: Un
Correction Un invariant
invariant de
de boucle
boucle est
est ici
ici««LaLavaleur
valeurdedelala
variable m après
après kk passages
passages enen boucle
boucle est
estleleterme
termedederang
rangkkdede
la suite définie
définie par
par (S
(S22).). »»
Complexité :: Comme
Complexité Comme pour
pour l’algorithme
l’algorithmeprécédent,
précédent,l’évaluation
l’évaluation
du nombre
nombre d’opérations
d’opérations élémentaires
élémentairesde decet
cetalgorithme
algorithmesuppose
supposelala
connaissance
connaissance de de la
la complexité
complexité dede l’évaluation
l’évaluationde
deff. .En
Ensupposant
supposant
que celle-ci
celle-ci est
est d’une
d’une seule
seule OPEL,
OPEL, lala complexité
complexitédedel’algorithme
l’algorithme
s’évalue alors
alors àà 5n + 33 OPEL.
5n + OPEL.
Ny
Ny
90
def S u i t e _ r e c u r r e n t e 2 ( f , a , b , n ) :
v=a
u=b
v , u= u , f ( u , v )
return ( v )
Dans ce script, nous avons utilisé la possibilité offerte en P YTHON

de réaliser une affectation simultanée de plusieurs variables.
7BMFVS NBYJNBMF EhVOF GPODUJPO
Soit f : [a, b] → R une fonction continue sur un segment. On sait que

f possède une valeur maximale M sur [a, b]. Pour déterminer une va-
leur approchée de M , nous utilisons la méthode dite du balayage.
Elle consiste à «discrétiser» l’intervalle [a, b] en introduisant la sub-
division régulière :
b−a
ak = a + k , pour k ∈ [[0, n]].
n
Une valeur approchée
de M sera obtenue comme maximum de la
liste de valeurs f (a0 ), f (a1 ), . . . , f (an ) .
-hBMHPSJUINF
Fonction V a l e u r _ m a x i m a l e ( f , a , b , n )
Donnees
f : fonctions
a , b , u , max , h : r é e l s
k,n : entiers
Debut
u <−− a
v <−− f ( a )
max <−− v
h <−− ( b−a ) / n
NR
91
Faire
u <−− u + h
v <−− f ( u )
S i v > max
A l o r s max <−− v
Fin S i
Fin F a i r e
Retourner ( max )
Fin

Spécification : La fonction oH2m`nKtBKH2 prend en entrée
une fonction 7, des réels et # ainsi qu’un entier naturel M. Elle
retourne une valeur approchée de la valeur maximale de f sur le
segment [a, b].
Terminaison : Cette boucle inconditionnelle se termine après n+
1 itérations.
Correction : Notons maxk la valeur de la variable informatique
Kt après k passages en boucle. Un invariant de boucle est la pro-
priété :
(Pk ) maxk = Kt {f (a0 ), f (a1 ), . . . , f (ak )}
Complexité : en comptant pour une seule OPEL l’évaluation de
f , la complexité de cet algorithme s’évalue à 7n + 14.
def V a l e u r _ m a x i m a l e ( f , a , b , n ) :
u=a
v=f ( a )
max=v
h=(b−a ) / n
f o r k i n r a n g e ( n+1) :
u=u+h
v=f ( u )
Nk
92
i f v>max
v>max ::
max=v
max=v
r e t u r n ((max
max))
#PÔUF
#PÔUF ËË PVUJMT
PVUJMT
Le module QTiBKBx2
QTiBKBx2 de
de SSCIPY
CIPY propose fonctionKBMBKBx2nb+H`
proposelalafonction KBMBKBx2nb+H`
o p t=m i n i m i zz ee_
_ssccaallaarr ((ff ,, bounds
bounds=(a
=(a,,bb)), ,method=
method=’ ’bounded
bounded’ ’) )

retourne
retournelalavaleur
valeurminimale de7 7
minimalede
opt.fun
entre
entreles bornesetet##
lesbornes
retourne
retourne l’abscisse
l’abscisse de
de cece
opt.x
minimum
minimum
«Son ordinateur
ordinateur était
était éteint
éteint parce
parceque
quedes
desoctets
octetsavaient
avaientrefroidi
refroidi
l’énergie de l’alphabet.
l’alphabet. »»
1IJMJQQF
1IJMJQQF +BGmFVY
+BGmFVY,,écrivain
écrivainetetpoète
poètefrançais.
français.
Nj
Nj
93
3ÏTPMVUJPO
3ÏTPMVUJPO OVNÏSJRVF
OVNÏSJRVF
EFT ÏRVBUJPOT
ÏRVBUJPOT OPO
OPO MJOÏBJSFT
MJOÏBJSFT
On considère
considère une
une fonction
fonction ff :: II →→ RRune
unefonction
fonctionsuffisamment
suffisamment
régulière. On
On suppose
suppose quequeff s’annule
s’annuleexactement
exactementune
unefois
foisdans
dansI,I,auau
point c. On cherche
cherche àà résoudre
résoudrenumériquement
numériquementl’équation
l’équation
ff(x)
(x)==00 UEV
UEV
c’est-à-dire àà obtenir
obtenir une
une valeur
valeurapprochée
approchéede
dec.c.
3FDIFSDIF
3FDIFSDIF EhVO
EhVO [ÏSP
[ÏSP QBS
QBS EJDIPUPNJF
EJDIPUPNJF
On considère
considère uneune fonction
fonction ff :: II → → RR une
unefonction
fonctionstrictement
strictement
monotone sur sur un
un intervalle
intervalle I. I. On
On suppose
suppose qu’il
qu’ilexiste
existeun
uncouple
couple
(a, b) ∈ I 22 tel
tel que
que aa << bb etetff(a) (b)0.0.
(a)××ff(b)
D’après le théorème
théorème des des valeurs intermédiairesappliqué
valeurs intermédiaires appliquéà àune
une
fonction injective
injective (car
(carstrictement
strictementmonotone),
monotone),ililexiste
existeun
ununique
uniqueélé-
élé-
ment c ∈ [a, b] tel
[a, b] tel que
que ff(c)
(c) =
=0.0.
Une démonstration
démonstration dede cece théorème
théorème repose
repose sur
surlalaconstruction
constructiondede
suites adjacentes
adjacentes par
par dichotomie.
dichotomie.
Plus précisément,
précisément, onon construit
construitpar
parrécurrence
récurrencedes suites(u(unn) )etet(v(v
dessuites n )n )
vérifiant pour
pour tout
tout entier
entier nn ∈∈ N
N::
•• uu00
uu11
······
uunnvvnn· · · ·vv1 1vv0 0
bb−−aa
(Cn ) •• vvnn −
− uunn =
= nn
22
•• ff(u
(unn)) × (a)
×ff(a) 0,0,ff(v (b)0.0.
(vnn))××ff(b)
On montre alors
alors que
queles
lessuites (unn))etet(v
suites(u (vnn))sont
sontadjacentes
adjacentesetetconvergent
convergent
N9
N9
94
toutes deux vers la solution c de l’équation UEV. De plus, pour tout
entier n ∈ N, on a
un c v n
L’avantage de cette méthode de résolution est qu’elle est construc-
tive, c’est-à-dire qu’elle fournit un algorithme qui permet d’appro-
cher la solution de l’équation f (x) = 0 mais avec également un bon
contrôle de l’erreur commise.
-hBMHPSJUINF

Fonction Z e r o _ d i c h o t o m i e ( f , a , b , e p s )
Donnees
f : fonction ;
a , b , u , v ,w, eps : r e e l s
Debut
u <−− a
v <−− b
Tant que v−u > 2∗ e p s
Faire
w <−− ( u+v ) / 2
S i f (w) ∗ f ( a ) 0
A l o r s u <−− w
Sinon v <−− w
Fin S i
Fin F a i r e
Retourner (w)
Fin

Spécification : La fonction w2`Qn/B+?QiQKB2 prend en argu-
ment une fonction 7 et deux réels -# et une précision 2Tb strictement
positive. Elle retourne une valeur approchée à 2Tb près de la solution
de l’équation UEV comprise entre a et b.
Terminaison : Notons pour tout entier n ∈ N, un , vn les valeurs
des variables informatiques u, v à l’issue du nième passage dans la
boucle conditionnelle. Comme nous allons le démontrer, un inva-
riant de boucle est alors la propriété (Cn ) définie précédemment. En
N8
95
particulier, les
les suites
suites (u
(unn)) etet(v
(vnn))vérifient
vérifient: :
bb−−aa
−uunn
vvnn − −−
−−
−−
→→0.0.
22nn n→∞
n→∞
Par définition
définition dede la
la notion
notion de
de limite,
limite, ilil existe
existeun
unentier
entiernn0 0teltelque
que
vn0 − unn00
22 eps.
eps. La
La boucle
bouclese
setermine
termineaprès aprèsnn00itérations.
itérations.
Correction :: Vérifions
Correction Vérifionsque
que(C
(Cnn))est
estun
uninvariant
invariantdedeboucle.
boucle.
Initialisation :: avant
• Initialisation avant lele premier
premier passage
passageenenboucle,
boucle,uu0 0 ==aaetet
bien uu00
v0 = b. On aa bien vv00,, vv00 −
−uu00 ==bb−−aaetetff(u (a)0,0,
(u0 )0 )∗∗ff(a)
f (b) × f (v00))
0.
0.
Hérédité :: Soit
• Hérédité Soit nn ∈∈ N
N tel
telque
que(C
(Cnn).).Au
Aucours dunnième
coursdu ièmepassage
passage
uunn+v
+vnn
en boucle, on
on définit
définit w = 22 . .
wnn =
Si f (wn
n)) aa le
le même
même signe
signeque
queff(a),
(a),ononpose
posealors
alorsuun+1 n netet
n+1==ww
on ne change
change pas
pas la
la valeur
valeurde
dev,
v,donc
doncvvn+1
n+1==vvnn. .
Sinon f (w
(wnn)) aa le
le même
mêmesigne
signeque
queff(b),
(b),on
onpose
posealors
alorsvvn+1
n+1==ww
nn
et on ne change
change paspas lala valeur
valeurdedeu,
u,donc
doncuun+1
n+1==uunn. .
Dans les deux
deux cas,
cas, on
on aa donc
donc::
unn
uun+1
n+1 vvn+1
n+1 vvnnetetvvn+1
n+1− −uun+1
n+1== 2 2
−u
vnvn −u
nn
(a) ×
f (a) × ff(u n+1))
(un+1 00etetff(b)
(b)××ff(v n+1))0.0.
(vn+1
Compte tenu
tenu que
que (C
(Cnn)) est
estvérifié,
vérifié,on
onen
endéduit
déduitaisément
aisément(C
(Cn+1
n+1).).
Conclusion :: en
• Conclusion en sortie
sortie dede boucle,
boucle, on
onaaCCnnest estvérifié
vérifiéetetvnv0n0−−
un0 2 eps.
eps. Comme
Comme cc est est compris
comprisentre
entreuunn0 0 etetvvnn0 ,0 ,wwn0n0est
estune
une
valeur approchée de cc àà 2Tb
approchée de 2Tbprès.
près.
Complexité :: Pour
Complexité Pourestimer
estimerlalacomplexité
complexitéde decet
cetalgorithme,
algorithme,conve-
conve-
nons de compter
compter l’évaluation
l’évaluationde deff en
enune
unevaleur
valeurcomme
commeune uneOPEL,
OPEL,
ce qui n’est pas
pas le
le cas
cas en
engénéral.
général.Avec
Aveccette
cetteconvention,
convention,chaque
chaquepas-
pas-
sage en boucle
boucle revient
revient àà 1111 OPEL.
OPEL.Pour
Pourque
quevv−−uusoit
soitinférieur
inférieurà à
b−a
b−a
2eps, il suffit
suffit que
que nn soit
soit supérieur
supérieurààNN ==�HQ;
�HQ;22 epseps �.�.Finalement,
Finalement,
la complexité
complexité s’évalue
s’évalue àà 11N
11N ++3,3,où
oùNNest
estde l’ordrededeHM(eps).
del’ordre HM(eps).
Ne
Ne
96
def Z e r o _ d i c h o t o m i e ( f , a , b , e p s ) :
a s s e r t f ( a ) ∗ f ( b ) <=0," f d o i t c h a n g e r de s i g n e "
u=a
v=b
w h i l e v−u > 2∗ e p s :
w=(u+v ) / 2
i f f ( a ) ∗ f (w) >= 0 :
u=w
else :

v=w
r e t u r n (w)
Remarques :
• l’instruction bb2ì 7UV 7U#V I4y-Ǵ7 /QBi +?M;2` /2 bB;M2Ǵ évite
l’exécution de la fonction w2`Qn/B+?QiQKB2 lorsque la fonction
f (a) × f (b) 0 n’est pas satisfaite.
• En revanche, l’hypothèse que f est strictement monotone sur I
sert uniquement à garantir que l’équation UEV f (x) = 0 possède
une unique solution sur I. Lorsque ce n’est pas le cas, la fonction
w2`Qn/B+?QiQKB2 U7--#-2TbV va retourner une valeur appro-
chée d’une solution de cette équation comprise entre a et b.
.ÏUIPEF EV QPJOU mYF
Soit g : [a, b] → [a, b] une fonction lipschitzienne de constante k ∈

]0, 1[, c’est-à-dire telle que
∀(x, y) ∈ [a, b]2 , |g(x) − g(y)| k|x − y|
Alors la suite (un ) définie par

• u0 = a
• ∀n ∈ N, un+1 = g(un )
Nd
97
converge vers l’unique point fixe c de g sur [a, b], c’est-à-dire l’unique
solution de l’équation
g(x) = x. UF V
De plus

∀n ∈ N, un − c k n (b − a)
Autrement dit, un est une valeur approchée du point fixe de g sur

[a, b]. L’intérêt de cette méthode est d’être simple à programmer.
En revanche, les conditions de convergence de la méthode ne sont
pas aisées à vérifier : sur quel intervalle [a, b] l’appliquer, quelle
constante k peut-on choisir ?
-hBMHPSJUINF
Fonction P o i n t _ f i x e ( g , a , N, e p s )
Donnees
g : fonction
n ,N : e n t i e r s
a , u , eps : r e e l s
Debut
n <−− 0
u <−− a
Tant que n < N et | g ( u)−u | > e p s
Faire
n <−− n+1
u <−− g ( u )
Fin F a i r e
S i | g ( u)−u | e p s
A l o r s Retourner ( u )
Fin

Spécification : La fonction prend en argument une fonction g,
un réel a, un nombre d’itérations maximal N et une précision eps.

Elle retourne une valeur approchée d’un point fixe de g si l’algo-
rithme converge, rien sinon.
N3
98
Terminaison : La boucle conditionnelle se terminera après N ité-
rations au maximum.
Correction : Un invariant de boucle est ici « après n itérations,
la valeur de la variable informatique u est le terme de rang n de la
suite récurrente (un )».
En sortie de boucle, si |g(un ) − un )| eps, alors un est une valeur
approchée de c. Sinon, l’algorithme n’a pas convergé et la fonction
ne retourne rien.
Complexité : Dans le pire des cas, si l’algorithme ne converge

pas, on effectue 9N + 7 OPEL. Lorsque au contraire, l’algorithme

converge, pour que |g(un ) − un | soit inférieur à eps, il suffit que
k n (b − a) soit inférieur à eps. Le plus petit entier N qui convienne
alors est de l’ordre de HM(|eps|).
def P o i n t _ f i x e ( g , a , N, e p s ) :
n=0
u=a
w h i l e ( n<N and a b s ( g ( u)−u)> e p s ) :
n=n+1
u=g ( u )
i f a b s ( g ( u)−u)<=e p s :
return (u)
Remarque : la méthode du point fixe peut être utilisée pour résoudre

l’équation UEV. En effet, si on pose g(x) = x ± f (x), on obtient
l’équivalence :
(F ) ∀x ∈ I, g(x) = x ⇐⇒ f (x) = 0 (E)
Ainsi, on s’est ramené par changement de fonction à un problème de

point fixe.
NN
99
.ÏUIPEF EF /FXUPO
Intuitivement, l’idée de base dans la méthode de Newton est de rem-

placer f par sa tangente. Plus précisément, partant d’un élément u0 =
a, on définit pour tout n ∈ N, un+1 comme étant l’abscisse du point
du plan, intersection de la tangente au graphe de f au point un avec
l’axe des abscisses (voir figure ci-dessous).
Comme l’équation de la tangente au point un s’écrit y = f (un ) +
f (un )(x − un ), un+1 est donc donné par :
f (un )
un+1 = un −
f (un )
Illustration
−2 −1 0 1 3
Admettons que cette suite récurrente soit bien définie (il faut pour
cela que pour tout n , un appartienne à I et que f (un ) soit non nul).
En ce cas, si (un ) converge vers c ∈ I, alors par unicité de la limite :
f (c)
c=c− , soit f (c) = 0
f (c)
Ainsi, la limite c est solution de UEV. Pour garantir que la suite soit
bien définie et converge vers la solution c de UEV, le résultat fonda-
mental est le suivant :
Théorème de Newton —. Soit c ∈ I et f : I → R une fonction
de classe C 2 . On suppose que f s’annule en c et que f et f ne
s’annulent pas dans I.
Ryy
100
Pour tout a ∈ I tel que f (a)f �� (a) 0, on considère la suite
(un )n∈N définie par u0 = a et la relation de récurrence :
f (un )
∀n ∈ N, un+1 = un − .
f � (un )
La suite (un )n∈N est bien définie et converge vers c.
Soit V un voisinage contenant les points d’itérations. Posons M =

bmTV |f �� (x)| et m = BM7V |f � (x)|. La formule de Taylor dans V
donne l’estimation :
2n −1
M n
|un − c| × |a − c|2 .
2m
-hBMHPSJUINF
Fonction Zero_newton ( f , df , a , N, e p s )
Donnees
f , d f : f o n c t i o n s d f e s t l a d é r i v é e de f
a , u , v , eps : r e e l s
n ,N : e n t i e r s
Debut
n <−− 0
u <−− a
v <−− u − f ( u ) / d f ( u )
Tant que ( n < N et | v−u | > e p s )
Faire
n <−− n+1
u <−− v
v <−− u − f ( u ) / d f ( u )
Fin F a i r e
S i | v−u | e p s
A l o r s Retourner ( v )
Fin
RyR
101
Spécification : La fonction w2`QnM2riQM prend en argument
une fonction 7 ainsi que sa dérivée /7 un réel un nombre maximal

d’itérations L et une précision 2Tb strictement positive. Elle retourne
une valeur approchée à 2Tb près de la solution de l’équation f (x) = 0
obtenue par la méthode de Newton à partir de la valeur initiale si
toutefois cette méthode converge, rien sinon.
Terminaison : La boucle conditionnelle se terminera après N
itérations au maximum.
Correction : Un invariant de boucle est ici « après n itérations,
la valeur de la variable informatique u est le terme de rang n de la

suite récurrente (un ) de la méthode de Newton».
En sortie de boucle, si |un+1 − un | eps, alors un est une valeur
approchée de c. Sinon, l’algorithme n’a pas convergé et la fonction
ne retourne rien.
Complexité : Dans le pire des cas, si l’algorithme ne converge
pas, on effectue 12N + 11 OPEL. Lorsque au contraire, l’algorithme

converge, pour que |un+1 − un | soit inférieur à eps, il suffit que
M 2n −1 n
× |a − c|2
2m
soit inférieurà eps. Le plus
petit entier N qui convienne alors est de
l’ordre de HM | HM(|eps|)| .
def Zero_newton ( f , df , a , N, e p s ) :
n=0
u=a
v=u−f ( u ) / d f ( u )
w h i l e ( n<N and a b s ( v−u)> e p s ) :
n=n+1
u=v
v=u−f ( u ) / d f ( u )
i f a b s ( v−u)<=e p s :
return ( v )
Ryk
102
.ÏUIPEF EF -BHSBOHF
La méthode de Lagrange est une variante de la méthode de Newton.

Soit f ∈ C 2 ([a, b], R) ayant une convexité déterminée (f de signe
constant dans [a, b]). Pour calculer un zéro c de f par la méthode de
Newton, la suite (un ) peut être définie de la manière suivante :
�
• u0 voisin de c
• ∀n ∈ N, f (un ) (un+1 − un ) = −f (un )

Dans certaines situations, la dérivée de f peut être très compliquée
voire impossible à calculer.
En remplaçant la dérivée par un accroissement fini entre un et un
point b, nous obtenons la méthode de Lagrange :
f (un ) − f (b)
∀n ∈ N (un+1 − un ) = −f (un )
un − b
un f (b) − bf (un )
soit un+1 =
f (b) − f (un )
D’où le schéma suivant :

⎧
⎨ • u0 = a voisin de c
un f (b) − bf (un )
⎩ • ∀n ∈ N, un+1 =
f (b) − f (un )
Lorsque la valeur initiale a est bien choisie, la suite (un ) ainsi définie
converge vers c.
L’avantage de cette méthode est qu’elle ne nécessite pas le calcul
de la dérivée f . L’inconvénient est que nous perdons la convergence
quadratique.
-hBMHPSJUINF
Fonction Z e r o _ l a g r a n g e ( f , a , b , N, e p s )
Donnees
f : fonction
u , v , eps : r é e l s
Ryj
103
n , N : e nn tt ii ee rrss
Debut
n <−− 0
u <−− a
v <−− ( u∗ u∗ ff ((b)−b∗
b)−b∗ff ((uu))))//((ff((b)−
b)−f f((uu))))
que ((n<N
Tant que n<N et et ||v−u|>
v−u|> eeppss))
F a i rree
n <−−
<−− n+1 n+1
u <−−
<−− vv
v <−
<− ((u∗ u∗ ff ((b)−b∗
b)−b∗ff((uu))))//((f f((b)−
b)−f f((uu) ) )
Fin FFaaiirree
S i | v−u || eeppss
Retourner((vv))
A l oorrss Retourner
Fin
Analyse de
de cet
cet algorithme
algorithme ::
Spécification fonctionw2`QnH;`M;2
Lafonction w2`QnH;`M;2prend prendenenargument
argument
fonction 7,7, deux
une fonction réels etet#,#,un
deux réels unnombre
nombremaximal d’itérationsLL
maximald’itérations
précision 2Tb
et une précision 2Tb strictement
strictement positive.
positive.Elle
Elleretourne
retourneuneunevaleur
valeur
approchée àà 2Tb
2Tb près
près de
de lala solution
solutiondedel’équation
l’équationff(x)(x)==00obtenue
obtenue
par la méthode
méthode de de Lagrange
Lagrangeààpartirpartirde
delalavaleur
valeurinitiale
initialeaasisitoutefois
toutefois
cette méthode
méthode converge,
converge, rien
riensinon.
sinon.
Terminaison :: La
Terminaison Laboucle
boucleconditionnelle
conditionnelleseseterminera
termineraaprès
aprèsNNité-
ité-
rations au maximum.
maximum.
Correction :: Un
invariant de
de boucle
boucleestestici
ici««après
aprèsnnitérations,
itérations,
la valeur de
de la
la variable
variable informatique
informatiqueuuest estleleterme
termedederang
rangnndedelala
suite récurrente
récurrente (u(unn)) de
de lalaméthode
méthodede deLagrange
Lagrange».».
En sortie de
de boucle,
boucle, sisi |u −uunn|| eps,
n+1 −
|un+1 eps,alors
alorsuunnest
estune
unevaleur
valeur
approchée dede c.
c. Sinon,
Sinon, l’algorithme
l’algorithmen’a n’apas
pasconvergé
convergéetetlalafonction
fonction
ne retourne
retourne rien.
rien.
Complexité :: dans
Complexité dansle
lepire
piredes
descas,
cas,lorsque
lorsquel’algorithme
l’algorithmeneneconverge
converge
pas, on effectue
effectue 12N
12N ++1111OPEL.
OPEL.
Ry9
Ry9
104
def Z e r o _ l a g r a n g e ( f , a , b , N, e p s ) :
n=0
u=a
v=(u∗ f ( b)−b∗ f ( u ) ) / ( f ( b)− f ( u ) )
w h i l e ( n<N and a b s ( v−u)> e p s ) :
n=n+1
u = v
v = ( u∗ f ( b)−b∗ f ( u ) ) / ( f ( b)− f ( u ) )
i f a b s ( v−u)<=e p s :

return ( v )
#PÔUF Ë PVUJMT
Le module optimize de S CIPY propose la fonction 7bQHp2 qui dispose

de multiples options.
retourne la solution obtenue en
initiant la recherche au voisinage
fsolve(f,x0)
de ty ou un message d’erreur le
cas échéant
« La révolution informatique fait gagner un temps fou aux

hommes, mais ils le passent avec leur ordinateur ! »
*TBBD "TJNPW, écrivain américain de science-fiction.
Ry8
105
*OUÏHSBUJPO OVNÏSJRVF
Le théorème fondamental du calcul intégral affirme que toute fonc-

tion f : I → R, continue sur un intervalle possède une primitive F
sur I. On peut alors calculer l’intégrale de f sur un segment inclus
dans I : b b
f (t) dt = F (t) = F (b) − F (a)
a a
Cependant l’existence de primitives sur f est un résultat théorique

qui ne donne pas de formule permettant d’obtenir F à partir de f .
L’interprétation « géométrique » de l’intégrale comme étant l’aire de
la région plane comprise entre le graphe de f et l’axe des abscisses
b
permet d’obtenir des valeurs approchées de f (t) dt.
a
.ÏUIPEF EFT SFDUBOHMFT
Le principe est de subdiviser le segment [a, b] en n intervalles déli-

mités par les points :
b−a
ak = a + k , pour k ∈ [[0, n]].
n
La longueur h = b−a
n est appelée le pas de la subdivision.
Sur l’intervalle [ak , ak+1 ], on remplace la fonction f par la fonction
b
constante égale à f (ak ) et l’intégrale f (t) dt est approchée par la
a
somme, notée Sn , des aires des n rectangles, comme on le visualise
sur la figure ci-après.
Rye
106
Ainsi :
b n−1
n−1

f (t) dt ≈ f (ak ) × h = h f (ak )
a k=0 k=0
Plus précisément, si f : [a, b] → R est une fonction de classe C 1 ,

nous avons :
b
2
∀n ∈ N , � Sn − f (t) dt bmT |f � (x)| (b − a)
2n
a axb

Illustration :
a b
-hBMHPSJUINF
Fonction I n t e g r a l e _ r e c t a n g l e ( a , b , f , n )
Donnees
f : fonction ;
a,b,h, S : reels
k,n : entiers
Debut
h <−− ( b−a ) / n
S <−− 0
Faire
S <−− S + f ( a+k ∗h )
Fin F a i r e
Retourner ( h∗S )
Fin
Ryd
107
Analyse de cet
cet algorithme
algorithme ::
Spécification fonction AMi2;`H2n`2+iM;H2
La fonction AMi2;`H2n`2+iM;H2prend prenden en
argument deux réels et
deux réels et #,
#, une fonction 77 définie
une fonction définie sur
sur [a,
[a,b]b]etetun
un
entier M. Elle retourne
retourne une
une valeur
valeurapprochée
approchéede del’intégrale
l’intégralededeaaààbbde de
f obtenue par la la méthode
méthode des
des rectangles
rectangles en
en subdivisant
subdivisantlelesegment
segment
[a, b] en n.
Terminaison :: La
terminaison de
de lala boucle
inconditionnellene
ne
pose pas de problème.
problème.
Correction :: Un Un invariant
invariant de deboucle
boucleest
estici
ici««après
aprèskkitérations,
itérations,lala
valeur de la variable
variable informatique
informatique SS estest égale
égaleààlalasomme
sommeff(a (a00))++
· · · + f (ak−1
k−1 ) ».
». En
En sortie
sortie de
de boucle,
boucle, c’est-à-dire
c’est-à-dire après
aprèsn nitérations,
itérations,
S ∗ h est précisément
précisément égale
égale àà SSnn..
Complexité :: À
Complexité À chaque
chaquepassage
passageenenboucle,
boucle,ililyyaa66OPEL.
OPEL.Compte
Compte
tenu des initialisations
initialisations et
et du
du retour
retour de
de résultat,
résultat,lalacomplexité
complexitéde
decet
cet
algorithme s’évalue
s’évalue àà 6n
6n ++ 66 OPEL.
OPEL.
-F
-F QSPHSBNNF
QSPHSBNNF FO
FO 1ZUIPO
1ZUIPO
def I n t e g r aa ll ee _
_rreeccttaannggllee ((aa,,bb,,ff ,,nn)) ::
h=(b−a ))//nn
S=0
f o r k iinn rraannggee ((nn)) ::
S=
S= S+f S+f ((a+k∗h
a+k ∗h))
r e t u r n ((S∗h
S∗h))
.ÏUIPEF EFT
EFT USBQÒ[FT
USBQÒ[FT
L’idée consiste
consiste àà remplacer
remplacer les
les rectangles
rectangles utilisés
utilisésdans
danslalaconstruc-
construc-
tion précédente
précédente par
par des
des trapèzes
trapèzes qui
qui s’appuient
s’appuientsursurlelegraphe
graphede
deff. .
Avec les notations
notations précédentes,
précédentes, on
on pose
pose::
n−1
n−1
− aa
bb − ff(a
(aii))+
+ff(a
(ai+1
i+1))
TTnn(f
(f)) =
=
nn 22
i=0
i=0
Ry3
Ry3
108
Illustration
a b

Clairement, pour une subdivision de même pas, l’approximation est
bien meilleure.
Effectivement, on peut démontrer le résultat suivant :
Si f est de classe C 2 sur [a, b], alors
b
3
Tn (f ) − f (t) dt M (b − a) ,
12n2
a
où M = bmT[a,b] |f |.
-hBMHPSJUINF
Fonction I n t e g r a l e _ t r a p e z e s ( a , b , f , n )
Donnees
f : fonction ;
a , b , h ,T : r e e l s
k,n : entiers
Debut
h <−− ( b−a ) / n
T <−− ( f ( a)+ f ( b ) ) / 2
Faire
T <−− T + f ( a+k ∗h )
Fin F a i r e
Retourner ( h∗T)
Fin
RyN
109
Spécification : La fonction AMi2;`H2ni`T2x2 prend en ar-
gument deux réels et #, une fonction 7 définie sur [a, b] et un entier
M. Elle retourne une valeur approchée de l’intégrale de a à b de f
obtenue par la méthode des trapèzes en subdivisant le segment [a, b]
en n.
Terminaison : La terminaison de la boucle inconditionnelle ne
Correction : Un invariant de boucle est ici après k itérations, la
valeur de la variable informatique T est égale à la somme :
k−1
f (a) + f (b)
T = + f (ai ).
2
i=1
En sortie de boucle, c’est-à-dire après n itérations, T vaut donc

n−1 n−1 n
f (a) + f (b) 1 1
T = + f (ai ) = f (ai ) + f (ai )
2 2 2
i=1 i=0 i=1
n−1

1
= [f (ai ) + f (ai+1 )]
2
i=0
T ∗ h est bien égal à Tn .

Complexité : À chacun des n − 1 passages en boucle, il y a
6 OPEL. Compte tenu des initialisations et du retour de résultat, la

complexité de cet algorithme s’évalue à 6n + 4 OPEL.
def I n t e g r a l e _ t r a p e z e ( f , a , b , n ) :
h= ( b−a ) / n
T= ( f ( a)+ f ( b ) ) / 2
T=T+f ( a+k ∗h )
r e t u r n h∗T
RRy
110
#PÔUF Ë PVUJMT
N UMPY dispose d’une fonction i`Tx qui permet de calculer la valeur

approchée d’une intégrale directement à partir de la liste des valeurs
de f .
Si t = [t0 , t1 , . . . , , tn ] et y est la distribution de valeurs de f corres-
pondantes, y = [f (t0 ), f (t1 ), . . . , f (tn )].
retourne la valeur approchée de

l’intégrale de f entre t0 et tn
trapz(y,x)
calculée par la méthode des tra-
pèzes
« Comme la Hongrie, le monde informatique a une langue qui

lui est propre. Mais il y a une différence. Si vous restez assez
longtemps avec des Hongrois, vous finirez bien par comprendre
de quoi ils parlent. »
%BWF #BSSZ, journaliste américain.
RRR
111
EFT ÏRVBUJPOT EJGGÏSFOUJFMMFT
Hormis quelques cas d’école, on ne sait pas déterminer d’expression

analytique exacte pour les solutions d’équations différentielles. On
s’intéresse alors à des fonctions qui approchent ces solutions, obte-
nues par la méthode d’Euler.
²RVBUJPO EJGGÏSFOUJFMMF TDBMBJSF
On souhaite résoudre le problème de Cauchy suivant :

�
y = f (t, y(t)) pour tout t ∈ [a, b]
UC1 V
y(a) = y0
Comme précédemment, on effectue une subdivision régulière de [a, b]

de pas h = b−a
n .
b−a
tk = a + k , pour k ∈ [[0, n]].
n
Il s’agit de déterminer une approximation de yk de la valeur exacte
y(tk ). Or d’après le théorème fondamental du calcul intégral, on a
pour k ∈ [[0, n − 1]] :
tk+1
y(tk+1 ) − y(tk ) = y � (u) du
tk
tk+1
= f (u, y(u)) du
tk
≈ hf (tk , y(tk ))
RRk
112
La méthode d’Euler consiste à poser que yk+1 − yk est exactement
égal à hf (tk , yk ).
Graphiquement, cela revient à remplacer le graphe de y par des fonc-
tions affines sur chaque sous-intervalle de la subdivision. D’un point
de vue algorithmique, on calculera les approximations y0 , y1 , y2
. . . de proche en proche à l’aide des relations :

y0 = y(a)
∀k ∈ [[0, n − 1]], yk+1 = yk + hf (tk , yk )

-hBMHPSJUINF
Fonction E u l e r _ s c a l a i r e ( a , b , y0 , f , n )
Donnees
f : f o n c t i o n de deux v a r i a b l e s
a,b,h : réels
n,k : entiers
t , y : l i s t e s de r é e l s
Debut
h <−− ( b−a ) / n
t <−− [ 0 pour k v a r i a n t de 0 à n ]
y <−− [ 0 pour k v a r i a n t de 0 à n ]
t [ 0 ] <−− a
y [ 0 ] <−− y0
Faire
t [ k +1] <−− t [ k ] + h
y [ k +1] <−− y [ k ] + h ∗ f ( t [ k ] , y [ k ] )
Fin F a i r e
Retourner ( t , y )
Fin

Spécification : La fonction 1mH2`nb+HB`2 prend en entrée
les bornes et # d’un intervalle, une valeur réelle initiale vny, une
fonction de deux variables 7 et un entier M. Elle retourne deux listes :
RRj
113
• une subdivision régulière (tk )k∈[[0,n]] du segment [a, b] en n sous-
intervalles ;
• les valeurs approchées (y[k])k∈[[0,n]] de la solution du problème de
Cauchy UC1 V aux points de la subdivision.
Correction : Un invariant de boucle est « après k itérations, les
k +1 premiers termes des listes t et y correspondent à ceux des suites
(tn ) et (yn )».
Complexité : Chaque passage en boucle génère 7 OPEL. Compte
tenu des initialisations et du retour du résultat, le nombre d’OPEL
s’évalue à 7n + 8.
def E u l e r _ s c a l a i r e ( a , b , y0 , f , n ) :
h= ( b−a ) / n
t =(n + 1 ) ∗ [ 0 ]
y=(n + 1 ) ∗ [ 0 ]
t [0]= a
y [ 0 ] = y0
t [ k +1] = t [ k ] + h
y [ k +1] = y [ k ] + h ∗ f ( t [ k ] , y [ k ] )
return ( t , y )
²RVBUJPO EJGGÏSFOUJFMMF WFDUPSJFMMF
Très souvent, l’état du système est décrit par plusieurs variables.

Dans ce cas, la loi d’évolution prend la forme d’un système d’équa-
tions différentielles linéaires :
�
y1 (t) = F1 (t, y1 (t), y2 (t))
y2� (t) = F2 (t, y1 (t), y2 (t))
RR9
114
Pour traiter ces systèmes d’équations différentielles, on considère
que la fonction F est vectorielle. Plus précisément, on considère les
deux inconnues y1 et y2 comme les coordonnées d’une fonction vec-
torielle : Y : I → R2
.
t �→ [y1 (t), y2 (t)]
De même, on pose F = [F1 , F2 ]. Ainsi, la loi d’évolution prend la
forme bien connue Y (t) = F (t, Y (t)). Finalement, nous pouvons
réécrire le système d’équations différentielles scalaires sous forme

d’une équation différentielle vectorielle :

Y = F (t, Y (t)) pour tout t ∈ [a, b]
UC2 V
Y (a) = Y0
-hBMHPSJUINF
Fonction E u l e r _ v e c t o r i e l ( a , b , Y0 , F , n )
Donnees
F : f o n c t i o n de deux v a r i a b l e s
a,b,h : réels
n,k : entiers
t : l i s t e s de r é e l s
Y : l i s t e s de v e c t e u r s
Y0 : v e c t e u r
Debut
h <−− ( b−a ) / n
Y <−− [ [ 0 pour k v a r i a n t de 0 à n ] ,

[ 0 pour k v a r i a n t de 0 à n ] ]
t [ 0 ] <−− a
Y [ 0 ] <−− Y0
Faire
t [ k +1] <−− t [ k ] + h
Y [ k +1] <−− Y [ k ] + h ∗ F ( t [ k ] , Y [ k ] )
Fin F a i r e
Retourner ( t , Y)
Fin
RR8
115
Analyse
Analyse de
de cet
cet algorithme
algorithme ::
Spécification fonction1mH2`np2+iQ`B2H
Lafonction 1mH2`np2+iQ`B2Hprend prendenenentrée
entrée
bornes et
les bornes et ## d’un
d’unintervalle,
intervalle,un
uncouple
couplededevaleurs
valeursréelles
réellesinitiales
initiales
uny, une
une fonction
fonction de de deux variables66etetun
deux variables entierM.M.Elle
unentier Elleretourne
retourne
deux listes
listes ::
• une subdivision
subdivision régulière
régulière(t(tkk))k∈[
k∈[[0,n]]du
[0,n]] dusegment
segment[a,
[a,b]b]enenn nsous-
sous-
intervalles
intervalles ;;
• les valeurs
valeurs approchées
approchées (Y (Y[k])
[k])k∈[
k∈[[0,n]]de
[0,n]] delalasolution
solutionduduproblème
problème
Cauchy UC
de Cauchy UC22VV aux
auxpoints
pointsde
delalasubdivision.
subdivision.
Terminaison :: La
terminaisonde
delalaboucle
inconditionnellenene
pose pas
pas de
de problème.
problème.
Correction :: Un
invariantdedeboucle
boucleestest««après
aprèsk kitérations,
itérations,lesles
k + 1 premiers
premiers termes
termes des
des listes
listesttetetYY correspondent
correspondentà àceuxceuxdesdes
suites (tnn)) et
et (Y
(Ynn)) ».
».
Complexité :: Chaque
Complexité Chaquepassage
passageenenboucle
bouclegénère
génère7 7OPEL.
OPEL.Compte
Compte
tenu des
des initialisations
initialisations etet du
du retour
retourdu
durésultat,
résultat,lelenombre
nombred’OPEL
d’OPEL
s’évalue àà 7n
7n ++ 8.
8.
-F
-F QSPHSBNNF
QSPHSBNNFFO
FO1ZUIPO
1ZUIPO
Si les algorithmes
algorithmes de de lala méthode
méthode d’Euler
d’Eulersont
sontpresque
presqueidentiques
identiques
entre versions
versions scalaire
scalaireetetvectorielle,
vectorielle,leurs
leursimplémentations
implémentationsenenP YTHON
P YTHON
diffèrent
diffèrent plus
plus notablement.
notablement.
commeu(F)
En effet, comme u(F)etet6Ui(F)-u(F)V
6Ui(F)-u(F)Vsont
sontdes
deslistes
listes(couples),
(couples),lelesym-
sym-
d’addition Y
bole d’addition Yserait
seraitinterprété
interprétécomme
commeconcaténation
concaténationdedelistes,
listes,dede
même que
que la multiplication?? 6Ui(F)-u(F)V.
la multiplication 6Ui(F)-u(F)V.
Pour contourner
contourner cette
cette difficulté,
difficulté,on
onpeut
peutfaire
faireces
cesopérations
opérations« «co-
co-
ordonnées
ordonnées par
par coordonnées
coordonnées »,», ouou bien
bienutiliser format``v
utiliserleleformat ``vdede
UMPY..
N UMPY
RRe
RRe
116
def EEuul leerr__vveec ct to or irei le(l a( ,ab, ,bY0
def , Y0, F,,Fn ,)n: ) :
h=h= ((b−a b−a)/ ) /nn
tt=[0
=[0 ffoor r kk i ni n r arnagneg(en(+1)] n +1)]
YY= =[[[[00, ,00] ] f of or r k k i ni n r arnagneg(en(+1)] n +1)]
tt[[00]]== aa
YY[[00]][[: :] ]== Y0 Y0[ [: ]: ]
ffoorr kk i n i n r ar an ng ge e ( n( )n :) :
tt[ [kk+1]
+1] ==t [t k[ ]k ]++h h
YY[ [kk++11] []0[ 0] ]==Y Y [ k[ ]k[ ]0[]0 ]+ +h∗F h∗F( t ([ kt ][ k, Y] [,kY][)k[ ]0)] [ 0 ]
YY[ [kk++11] []1[ 1] ]==Y Y [ k[ ]k[ ]1[]1 ]+ +h∗F h∗F( t ([ kt ][ k, Y] [,kY][)k[ ]1)] [ 1 ]

rreettuurrnn ( (t t, Y), Y)
-F
-FQSPHSBNNF
QSPHSBNNFBWFD
BWFD/VNQZ
/VNQZ
def EEuul leerr11((aa, b, b, Y0
def , Y0, F, F, n, )n :) :
h=
h= ((b−a b−a)/ ) /nn
p=l
p=leenn((Y0 Y0) )
t=np
t=np. .l li inns sppa ac ce e( a( a, b, ,bn+1)
, n+1)
Y=np
Y=np. .zzeer roos s( (s hs ha pa ep=(p e =(p , n,+1)
n +1)
, d ,t dy pt ye=f
p e=f l o al ot )a t )
Y[
Y[ ::,,00] ]== Y0 Y0[ [: :, 0, 0] ]
ffoorr kk i n i n r ar an ng ge e( n( )n :) :
YY[ [: :, ,k+1]=
k+1]=YY [ :[ ,:k]+h∗F
, k ]+h∗F ( t ([ tk [] k, Y] [, Y: ,[ k: ],)k ] )
rreettuurrnn ( (t t, Y), Y)
Remarques
Remarques : :
• Ici,
Ici, les
les vecteurs
vecteursououlistes
listesdedevecteurs
vecteurssont
sont
desdestableaux
tableaux
de type
de type
M/``v.
M/``v.IlIlen enva ainsidedeu-u-uy-
vaainsi uy-i. i.
DeDemême
mêmela fonction
la fonction 6 passée
6 passée
en en
paramètre
paramètreest estune
unefonction
fonctiondededeuxdeux variables
variables
: un: un
réelréel
et un
et tableau
un tableau
(p,1).
(p,1). Elle
Elleretourne
retourneégalement
égalementunun tableau
tableau
(p,1).
(p,1).
• Cette
Cette dernière
dernièreversion
versionpermet
permetdedetraiter
traiter
desdes
équations
équations
différen-
différen-
pp
tielles
tiellesvectorielles
vectoriellesdans
dansRR, soit
, soit
desdes
systèmes
systèmesde de
p équations
p équations
différentielles.
différentielles.
RRd
RRd
117
#PÔUF Ë PVUJMT
Pour résoudre le problème de Cauchy

y (t) = f (y(t), t)
(C)
y(t0 ) = y0
où y est une fonction à valeurs réelles ou vectorielles, on utilise la

fonction Q/2BMi du module b+BTvXBMi2;ì2
odeint(f,y0,t) retourne la solution du problème de Cauchy (C)
Ici, i est un tableau de valeurs de la forme t = [t0 , t1 , ..., tn ]. La so-

lution retournée correspond à la distribution des valeurs approchées
de f aux différents instants t0 , t1 , . . . , tn .
²RVBUJPO EJGGÏSFOUJFMMF EhPSESF TVQÏSJFVS
Une équation différentielle scalaire d’ordre supérieur peut se rame-

ner à une équation différentielle d’ordre 1, à valeur vectorielle.
Prenons l’exemple d’une équation différentielle scalaire d’ordre 2
résolue en y de la forme :
y = f (t, y(t), y (t))

y
Nous allons introduire l’inconnue Y = de sorte que cette
y
équation puisse s’écrire (matriciellement) sous la forme :

y(t) y (t)
=
y (t) f (t, y(t), y (t))
Ainsi, en définissant la fonction vectorielle

F (t, y0 , y1 ) = [y1 , f (t, y0 , y1 )],
on se ramène à résoudre l’équation différentielle d’ordre 1 :

Y (t) = F (t, Y (t))
RR3
118
Plus précisément, on résout numériquement le problème de Cauchy
d’ordre 2 :
��
y = f (t, y(t), y � (t)) pour tout t ∈ [a, b]
UC3 V
y(a) = d0 , y � (a) = d1
-hBMHPSJUINF
Fonction E u l e r _ o r d r e 2 ( a , b , d0 , d1 , f , n )
Donnees

a , b , d0 , d1 , h : r é e l s
t , Y0 , Y1 : l i s t e s de r é e l s
k,n : entiers
f : fonction
Debut
h <−− ( b−a ) / n
Y0 <−− [ 0 pour k v a r i a n t de 0 à n ]
Y1 <−− [ 0 pour k v a r i a n t de 0 à n ]
t [ 0 ] <−− a
Y0 [ 0 ] <−− d0
Y1 [ 0 ] <−− d1
Faire
t [ k +1] <−− t [ k ] + h
Y0 [ k +1] <−− Y0 [ k ] + h ∗ Y1 [ k ]
Y1 [ k +1] <−− Y1 [ k ] + h ∗ f ( t [ k ] , Y0 [ k ] , Y1 [ k ] )
Fin F a i r e
Retourner ( t , Y0 )
Fin

Spécification : La fonction 1mH2`k prend en entrée les bornes
et # d’un intervalle, un couple de valeurs réelles initiales /y-/R,
une fonction de trois variables 7 et un entier M. Elle retourne deux
listes :
• une subdivision régulière (tk )k∈[[0,n]] du segment [a, b] en n sous-
intervalles ;
RRN
119
• les valeurs approchées (Y 0[k])k∈[[0,n]] de la solution du problème
de Cauchy UC3 V aux points de la subdivision.
Correction : Un invariant de boucle est « après k itérations, les
k + 1 premiers termes des listes t et Y 0 correspondent à ceux des
suites (tn ) et (Y 0n ) obtenu par la méthode d’Euler ».
Complexité : Chaque passage en boucle génère 9 OPEL. Compte
tenu des initialisations et du retour du résultat, le nombre d’OPEL
s’évalue à 9n + 10.
def E u l e r _ o r d r e 2 ( a , b , d0 , d1 , f , n ) :
h= ( b−a ) / n
t =[0 f o r k i n r a n g e ( n +1)]
Y0=[0 f o r k i n r a n g e ( n +1)]
Y1=[0 f o r k i n r a n g e ( n +1)]
t [0]= a
Y0 [ 0 ] = d0
Y1 [ 0 ] = d1
t [ k +1] = t [ k ] + h
Y0 [ k +1] = Y0 [ k ] + h∗Y1 [ k ]
Y1 [ k +1] = Y1 [ k ] + h∗ f ( t [ k ] , Y0 [ k ] , Y1 [ k ] )
r e t u r n ( t , Y0 )
« L’ordinateur est né pour résoudre des problèmes qui n’exis-

taient pas auparavant. »
#JMM (BUFT, informaticien américain.
Rky
120
EhVO TZTUÒNF MJOÏBJSF
On s’intéresse dans ce chapitre à la résolution de systèmes (S) de n

équations linéaires à n inconnues de la forme :

⎧
⎪
⎪ a0,0 x0 + a0,1 x1 + a0,2 x2 +· · ·+ a0,n−1 xn−1 = b0
⎪
⎪
⎨ 1,0 x0 + a1,1 x1 + a1,2 x2 +· · ·+ a0,n−1 xn−1 = b1
⎪ a
a2,0 x0 + a2,1 x1 + a2,2 x2 +· · ·+ a0,n−1 xn−1 = b2
⎪
⎪
⎪ .. .. ..
⎪
⎪ . . .
⎩
an−1,0 x0 +an−1,1 x1 +an−1,2 x2 +· · ·+an−1,n−1 xn−1 =bn−1
Un tel système peut être représenté par l’équation matricielle :
AX = B
où A est la matrice carrée d’ordre n :

⎛ ⎞
a0,0 a0,1 a0,2 ··· a0,n−1
⎜ a1,0 a1,1 a1,2 ··· a1,n−1 ⎟
⎜ ⎟
⎜ a2,0 a a2,2 ··· a2,n−1 ⎟
A=⎜ 2,1 ⎟
⎜ .. .. .. ⎟
⎝ . . . ⎠
an−1,0 an−1,1 an−1,2 · · · an−1,n−1
et les matrices colonnes X et b sont données par :
X =t [x0 x1 x2 · · · xn−1 ] et B =t [b0 b1 b2 · · · bn−1 ].
Lorsque (S) est de Cramer, c’est-à-dire ayant une unique solution,

la méthode de Gauss permet de se ramener à la résolution d’un sys-
tème triangulaire inversible (T ), c’est-à-dire de la forme :
RkR
121
⎧
⎪
⎪ a0,0 x0 + a0,1 x1 + a0,2 x2 +· · ·+ a0,n−1 xn−1 = b0
⎪
⎪
⎪
⎨ a1,1 x1 + a1,2 x2 +· · ·+ a1,n−1 xn−1 = b1
a2,2 x2 +· · ·+ a2,n−1 xn−1 = b2
⎪
⎪
⎪ .. ..
⎪
⎪ . .
⎩
an−1,n−1 xn−1 =bn−1
où les coefficients diagonaux a0,0 , . . . , an−1,n−1 sont non nuls.
3ÏTPMVUJPO EhVO TZTUÒNF USJBOHVMBJSF
On résout un tel système par remontée. Cela consiste à résoudre la

dernière équation, puis de remonter à l’avant-dernière en substituant
à xn−1 sa valeur. Ainsi, l’avant-dernière équation est une équation
du premier degré en xn−2 que l’on résout, puis on remonte à la
(n − 2)ième équation en substituant aux inconnues xn−1 et xn−2 les
valeurs précédemment obtenues et ainsi de suite.
-hBMHPSJUINF
Fonction S o l u t i o n _ r e m o n t e e (A , B) :
Donnees
A = A[ i ] [ j ] : matrice carrée
X =X [ i ] [ 0 ] , B=B [ i ] [ 0 ] : m a t r i c e s c o l o n n e s
somme : r é e l
i , j ,n : entiers
Debut
# r e s o u t p a r r e m o n t e e un SEL t r i a n g u l a i r e AX=b
n <−− L o n g u e u r (A) # nombre de l i g n e s ,
X <−− [ [ 0 ] pour i v a r i a n t de 0 à n −1]
Pour i v a r i a n t de n−1 à 0
F a i r e # xi = (bi − ai,i+1 xi+1 + · · · + ai,n−1 xn−1 ) /ai,i
somme <−−0
Pour j v a r i a n t de i +1 à n−1
Faire
somme <−− somme + A [ i ] [ j ] ∗ X [ j ] [ 0 ]
Fin F a i r e
X [ i ] [ 0 ] <−− (B [ i ] [ 0 ] − somme ) /A [ i ] [ i ]
Rkk
122
Fin F a i r e
Retourner (X)
Fin

Spécification : La fonction aQHmiBQMn`2KQMi22 prend en entrée
une matrice triangulaire inversible A, sous forme d’une liste de listes
et une matrice colonne B sous forme d’une liste. Elle retourne en sor-
tie l’unique matrice colonne X solution du système linéaire AX =

B, elle-même sous forme d’une liste.
Terminaison : La terminaison des deux boucles inconditionnelles
ne pose pas de problème.

Correction : Notons pour i ∈ [[0, n − 1]], xi la i + 1ième coordon-
née du vecteur colonne solution, X = t [x0 · · · xn−1 ]. Un invariant
de boucle est :
(Pi ) X[n − 1][0] = xn−1 , . . . , X[i][0] = xi .
• Initialisation : Lors du premier passage en boucle, i = n − 1. Par

conséquent la variable bQKK2 est nulle et
X[n − 1][0] = B[n − 1]/A[n − 1][n − 1]
coïncide bien avec xn−1 .

• Hérédité : Soit i tel que Pi est vraie. Au prochain passage en
boucle, la variable bQKK2 prend la valeur
n−1

somme = A[i − 1][j]X[j][0].
j=i
Dans cette somme, n’interviennent que les X[j][0] pour j i. D’après

n−1

Pi , on a somme = Ai−1,j xj . Par conséquent,
j=i
n−1

X[i − 1][0] = bi−1 − Ai−1,j xj /Ai−1,i−1
j=i
Rkj
123
Ce qui coïncide également avec xi−1 .
• Conclusion : En sortie de la boucle principale, on a bien
X[n − 1][0] = xn−1 , . . . , X[0][0] = x0 .
La liste retournée est donc celle des coordonnées du vecteur solution.

Complexité : Le nombre de passages en boucle principale est
égal à n, mais le nombre d’OPEL à chaque passage dépend de i.

Ainsi, dans la boucle principale, le nombre d’OPEL est égal à :
n−1
n(n − 1)
[4 + 4 × (n − i − 1)] = 4n + 4 = 2n2 + 2n.
2
i=0
Compte tenu des initialisations et du retour de résultat, le nombre

d’OPEL est de 2n2 + 2n + 3.
def S o l u t i o n _ r e m o n t e e (A , B) :
# r e s o u t p a r r e m o n t e e un SEL t r i a n g u l a i r e
n= l e n (A)
X= [ [ 0 ] f o r i i n r a n g e ( n ) ]
f o r i i n r a n g e ( n−1,−1,−1) :
somme=0
f o r j i n r a n g e ( i +1,n ) :
somme=somme + A [ i ] [ j ] ∗ X [ j ] [ 0 ]
X [ i ] [ 0 ] = ( B [ i ] [ 0 ] − somme ) /A [ i ] [ i ]
r e t u r n (X)
#PÔUF Ë PVUJMT
Le module linalg de S CIPY propose la fonction bQHp2ni`BM;mH` qui

résout les systèmes triangulaires -supérieurs par défaut)
si A est une matrice triangulaire,
retourne la solution du système
solve_triangular(A,B)
AX = B, ou bien un message
d’erreur le cas échéant
Rk9
124
0QÏSBUJPOT ÏMÏNFOUBJSFT TVS MFT MJHOFT EhVO TZT
UÒNF PV EhVOF NBUSJDF
Le théorème de Gauss montre que tout système de Cramer est équi-

valent à un système triangulaire inversible. En outre, la démonstra-
tion de ce théorème fournit un algorithme que nous détaillerons dans
la prochaine section.
Les outils de base pour mettre en œuvre cette méthode sont les opéra-

tions élémentaires sur les lignes d’un système (ou d’une matrice A).
Ces opérations consistent à :
• Rechercher dans une colonne fixée de A, disons celle d’indice i,
le coefficient Aj,i qui a la plus grande valeur absolue parmi tous les
coefficients Ak,i avec k i. Ce coefficient sera appelé pivot.
• Échanger deux lignes (Li et Lj ) de la matrice A.
• Ajouter à la ligne Li un multiple d’une autre ligne, Lj .
-FT BMHPSJUINFT
Fonction C h e r c h e r _ p i v o t (A , i )
Donnees
A : matrice
i , j ,k,n : entiers
Debut
n <−− L o n g u e u r (A) # nombre de l i g n e s de A
j <−− i
Pour k v a r i a n t de i +1 à n−1
Faire
Si |A[ k ] [ i ] | > |A[ j ] [ i ] |
A l o r s j <−− k
Fin S i
Retourner ( j )
Fin
Fonction E c h a n g e r _ l i g n e (A , i , j )
Donnees
A : matrice
Rk8
125
temp : r é e l
Debut
n <−− L o n g u e u r (A [ 0 ] ) # nombre de c o l o n n e s de A
Faire
temp <−− A [ i ] [ k ]
A [ i ] [ k ] <−− A [ j ] [ k ]
A [ j ] [ k ] <−− temp
Fin F a i r e
Fin
Fonction A j o u t e r _ l i g n e (A , i , j , mu)
Donnees
A : matrice
mu : r é e l
Debut
n <−− L o n g u e u r (A [ 0 ] ) # nombre de c o l o n n e s de A
Faire
A [ i ] [ k ] <−− A [ i ] [ k ] + mu ∗ A [ j ] [ k ]
Fin F a i r e
Fin
Remarque : Les deux dernières fonctions 1+?M;2`nHB;M2 d’une

part et DQmi2`nHB;M2 d’autre part, nne retournent rien.
Elles modifient la matrice A « sur place ».
Analyse de ces algorithmes :
Spécification :
• La fonction *?2`+?2`nTBpQi prend en entrée une matrice et

un numéro de colonne B et retourne le numéro de la ligne D du pivot.
• La fonction 1+?M;2`nHB;M2 prend en entrée une matrice et
deux numéros de lignes B et D. Elle échange dans la matrice A les
lignes Li et Lj .
• La fonction DQmi2`nHB;M2 prend en entrée une matrice , deux
numéros de lignes B-D et un réel Km. Elle remplace dans la matrice A
la ligne Li par Li + mu · Lj .
Rke
126
Terminaison : Les terminaisons de ces boucles inconditionnelles
ne posent pas de problème.
Complexité :
• Le nombre d’itérations dans la fonction *?2`+?2`nTBpQi est de
n − i − 1. À chaque passage, il y a 5 OPEL, donc la complexité de
cet algorithme est de 5(n − i) − 2.
• Le nombre d’OPEL de la fonction 1+?M;2`nHB;M2 est de 4n+1.
• Le nombre d’OPEL de la fonction DQmi2`nHB;M2 est également

de 4n + 1.
-FT QSPHSBNNFT FO 1ZUIPO

def C h e r c h e r _ p i v o t (A , i ) :
n=l e n (A)
j=i
f o r k i n r a n g e ( i +1,n ) :
i f a b s (A [ k ] [ i ] ) > a b s (A [ j ] [ i ] ) :
j = k
return j
def E c h a n g e r _ l i g n e (A , i , j ) :
n=l e n (A [ 0 ] )# l e nombre de c o l o n n e s
A[ i ] [ k ] ,A[ j ] [ k ] = A[ j ] [ k ] , A[ i ] [ k ]
def A j o u t e r _ l i g n e (A , i , j , mu) :
n=l e n (A [ 0 ] )# l e nombre de c o l o n n e s
A [ i ] [ k ] = A [ i ] [ k ] + mu ∗ A [ j ] [ k ]
3ÏTPMVUJPO EhVO TZTUÒNF QBS NÏUIPEF EF (BVTT
D’après le théorème de Gauss, tout système de Cramer est équi-

valent à un système triangulaire inversible, c’est-à-dire ayant tous ses
Rkd
127
coefficients diagonaux non nuls. En effet, considérons le système de
Cramer :
⎧
⎪ (0) (0) (0) (0)
⎪
⎪ a0,0 x0 + a0,1 x1 + · · · + a0,n−1 xn−1 = b0
⎪
⎪
⎪
⎨ a(0) x0 + a(0) x1 + · · · + a(0) xn−1 = b(0)
1,0 1,1 0,n−1 1
⎪ .. .. .. ..
⎪
⎪
⎪ . . . .
⎪
⎪
⎩ (0) (0) (0) (0)
an−1,0 x0 + an−1,1 x1 + · · · + an−1,n−1 xn−1 = bn−1
Notons A(0) la matrice carrée d’ordre n constituée des coefficients

de (S) et la matrice colonne B (0) formée des seconds membres. On
a donc
(S) ⇐⇒ A(0) X = B (0)
[1] Chercher un pivot : On observe que tous les coefficients de x0
ne sont pas nuls (sans quoi (S) n’aurait pas une unique solution).
On recherche parmi ces coefficients celui qui a la plus grande valeur
absolue, on l’appelle le pivot.
[2] Échanger deux lignes : On échange si nécessaire la ligne d’in-
dice 0 avec celle du pivot pour ramener le pivot en haut à droite de la
matrice. On obtient
⎧
⎪ (0) (0) (0) (0)
⎪
⎪ ã0,0 x0 + ã0,1 x1 + · · · + ã0,n−1 xn−1 = b̃0 (L0 )
⎪
⎪
⎪
⎨ ã(0) x0 + ã(0) x1 + · · · + ã(0) xn−1 = b̃(0) (L1 )
1,0 1,1 0,n−1 1
⎪ .. .. .. ..
⎪
⎪
⎪ . . . .
⎪
⎪
⎩ (0) (0) (0) (0)
ãn−1,0 x0 + ãn−1,1 x1 + · · · + ãn−1,n−1 xn−1 = b̃n−1 (Ln−1 )
(0)
où le pivot ã0,0 est en première position.
[2] Ajouter aux lignes un multiple de celle du pivot : À pré-
sent, nous allons éliminer l’inconnue x0 des n − 1 dernières lignes
du système en leur ajoutant le bon multiple de L0 . Plus précisément,
Rk3
128
on effectue les opérations élémentaires :
(0)
ãi,0
∀i ∈ [[1, n − 1]], Li ← L i − (0)
· L0
ã0,0
On obtient alors le système A(1) X = B (1) :

⎧
⎪ (1) (1) (1) (1)
⎪
⎪ a0,0 x0 + a0,1 x1 + · · · + a0,n−1 xn−1 = b0
⎪
⎪
⎪

⎨ (1) (1) (1)
a1,1 x1 + · · · + a0,n−1 xn−1 = b1
⎪ .. .. ..
⎪
⎪
⎪ . . .
⎪
⎪
⎩ (1) (1) (1)
an−1,1 x1 + · · · + an−1,n−1 xn−1 = bn−1
À la fin de ce premier cycle, nous avons placé un pivot en première

position et « vidé » la colonne en dessous. Ensuite, il s’agit de re-
prendre le cycle à l’étape [1] au sous-système constitué des n − 1
dernières équations. On obtient ainsi successivement :
(S) ⇐⇒ A(0) X = B (0)
⇐⇒ A(1) X = B (1)
..
.
⇐⇒ A(n−1) X = B (n−1)
Ce dernier système ayant au moins n − 1 pivots sur la diagonale,

il en a forcément exactement n : il s’agit d’un système triangulaire
inversible.
-hBMHPSJUINF
Fonction S o l u t i o n _ G a u s s (A , B)
Donnees
A , vA : m a t r i c e s c a r r é e s s o u s f o r m e de l i s t e
B , vB : m a t r i c e s c o l o n n e s s o u s f o r m e de l i s t e
mu : r é e l
Debut
RkN
129
n <−− L o n g u e u r (A)
vA <−− A #on t r a v a i l l e s u r d e s c o p i e s de A
vB <−− B # et de B que l ‘ on p o u r r a m o d i f i e r
# t r i g o n a l i s a t i o n du s y s t è m e
Pour i v a r i a n t de 0 à n−1
Faire
j <−− C h e r c h e r _ p i v o t ( vA , i )
Si j < i
A l o r s # r e m o n t e r l a l i g n e du p i v o t
E c h a n g e r _ l i g n e ( vA , i , j )
E c h a n g e r _ l i g n e ( vB , i , j )
Fin S i
Pour k v a r i a n t de i +1 à n−1
F a i r e # é c h e l o n n e r s o u s vA [ i ] [ i ]
mu= −vA [ k ] [ i ] / vA [ i ] [ i ]
A j o u t e r _ l i g n e ( vA , k , i , mu)
A j o u t e r _ l i g n e ( vB , k , i , mu)
# r é s o l u t i o n par remontée
Retourner S o l u t i o n _ r e m o n t e e ( vA , vB ) )
Fin

Spécification : La fonction aQHmiBQMn:mbb prend en entrée
une matrice carrée inversible 4(B)(D) ainsi qu’une matrice colonne

"4"(B)(y). Elle retourne l’unique solution du système d’équations
linéaires représenté matriciellement par l’équation AX = B, sous la
forme d’une matrice colonne s4s(B)(y).
Terminaison : L’algorithme ne mettant en jeu que des boucles
inconditionnelles, sa terminaison est indubitable.
Correction : Notons pour i 0, vA(i) et vB i) les valeurs des
variables informatiques p et p" après i passages dans la boucle
principale. Un invariant de boucle est alors :
« vA(i) = A(i) et vB (i) = B (i) ».
Rjy
130
Conformément à ce qui a été expliqué précédemment, on sait qu’en
sortie de boucle, après n étapes, A(n) est une matrice triangulaire
supérieure à coefficients diagonaux tous non nuls et que
AX = B ⇐⇒ A(n) X = B (n)
On peut donc appliquer la fonction aQHmiBQMn`2KQMi22 pour obtenir

la solution du système initial.
Complexité : La boucle principale compte n itérations. À cha-

cune de ces itérations, on effectue une boucle secondaire qui compte
n − i − 1 itérations. Finalement, chaque passage dans cette deuxième
boucle fait deux appels à la fonction DQmi2`nHB;M2 dont on sait
qu’elle coûte 4n + 1 OPEL !
Au final, le nombre d’OPEL est de l’ordre de n3 .
def S o l u t i o n _ G a u s s (A , B) :
" " R é s o l u t i o n de AX = B " "
n = l e n (A)
vA = [ A [ i ] [ : ] f o r i i n r a n g e ( n ) ]
vB = [ B [ i ] [ : ] f o r i i n r a n g e ( n ) ]
# t r i g o n a l i s a t i o n du s y s t è m e
for i in range (n) :
j = C h e r c h e r _ p i v o t ( vA , i )
if j > i :
E c h a n g e r _ l i g n e ( vA , i , j )
E c h a n g e r _ l i g n e ( vB , i , j )
f o r k i n r a n g e ( i +1,n ) :
mu=−vA [ k ] [ i ] / f l o a t ( vA [ i ] [ i ] )
A j o u t e r _ l i g n e ( vA , k , i , mu)
A j o u t e r _ l i g n e ( vB , k , i , mu)
# r e s o l u t i o n par remontee
r e t u r n ( S o l u t i o n _ r e m o n t e e ( vA , vB ) )
RjR
131
#PÔUF Ë PVUJMT
Le module linalg de S CIPY propose la fonction bQHp2 qui résout les

systèmes d’équations linéaires :
(S) AX = B
retourne la solution du système

solve(A,B) AX = B, ou bien un message
d’erreur le cas échéant
« Le nombre de femmes que j’aurais eues si je n’avais pas

un P YTHON chez moi, c’est fou. L’embarras du choix, c’est
l’angoisse. »
3PNBJO (BSZ, écrivain français.
Rjk
132
5SPJTJÒNF QBSUJF
"-(03*5).&4 %& %&69*µ.& "//²&
Partie 3
Algorithmes
de deuxième année
Algorithme
Le mot algorithme, anagramme du mot logarithme, semble
tout droit tiré de vocables grecs. Il n’en est rien puisqu’il
provient du nom latinisé puis francisé du mathématicien persan
LE SAVIEZ-VOUS ?
Al-Khwarizmi qui vivait à Bagdad au début du IXe siècle.

On doit à ce savant une méthode de résolution complète des
équations du second degré, en quelque sorte un algorithme ;
Rjjd’un ouvrage expliquant l’utilisation des
il est aussi l’auteur
chiffres arabes, ceux que nous utilisons. Son ouvrage fut traduit
en latin au Moyen Âge et son nom transformé en Algorithmus.
Le premier algorithme connu est celui de la division
euclidienne élaboré par Euclide au IIIe siècle avant notre ère.
De nombreux autres sont apparus en mathématiques mais le
développement de l’informatique leur a donné de nos jours un
rôle fondamental dans la gestion de l’activité humaine.
"MHPSJUINFT EF USJ
Dans tout le chapitre, on décrit des algorithmes pour trier des listes
de nombres. On spécifie ici le type entier pour les éléments des listes
considérées, mais les fonctions P YTHON écrites fonctionnent aussi
bien avec des listes contenant des entiers et/ou des flottants.
5SJ QBS JOTFSUJPO
Le principe de ce tri est le suivant. On découpe la liste G considérée

en deux sous-listes, la première triée et la deuxième contenant le reste
des éléments de G. On considère le premier élément de la partie non-
triée, et on l’insère dans la partie triée en comparant successivement
aux élément à sa gauche, comme dans les diagrammes suivants :
En répétant ce procédé on obtient une liste triée une fois inséré le

dernier terme de la liste. On peut utiliser moins d’affectations en
stockant la valeur que l’on insère et en se contentant de faire des
copies successives des élements vers la droite. Ainsi on obtient cette
fois-ci les diagrammes :
Rj9
134
À la dernière étape on a recopié le 4 stocké à la place du dernier
élément déplacé.
-hBMHPSJUINF
Fonction T r i I n s e r t i o n ( L )
Donnees
L : l i s t e d ‘ entiers ,
a , i , j : entier
Debut
Pour i v a r i a n t de 1 à l e n ( L )
Faire
a <−− L [ i ]
j <−− i
Algorithmes de 2e année
Tant Que j > 0 et L [ j −1] > a
Faire
L [ j ] <−− L [ j −1]
j <−−j −1
Fin F a i r e
L [ j ] <−− a
Fin F a i r e
Retourner L
Fin

Spécification : Cette fonction prend en entrée une liste d’entiers
G et retourne la liste triée contenant les mêmes éléments que G. À
noter que l’ordre initial des éléments de G est perdu dans la transpo-
sition P YTHON de cet algorithme.
Rj8
135
Terminaison : La suite des valeurs de j dans la boucle Tant Que
est à valeurs entières et strictement décroissante. Cette boucle ter-
mine donc forcément, ne serait-ce qu’à cause de la condition j > 0.
Correction : On a pour invariant de boucle : "la liste formée des
éléments de G d’indice strictement inférieur à i est triée".
Complexité : On note n la longueur de la liste G. Dans le pire
des cas, la liste est constituée de valeurs décroissantes. On a alors i
passages dans la boucle Tant Que et comme on a 7 OPEL dans cette
boucle ainsi que 3 OPEL dans la boucle Pour on obtient un total de
n
n(n + 1) 7n2 + 13n
3 + 7i = 3n + 7 =
2 2
i=1
OPEL. Cet algorithme est donc de complexité quadratique en n.
def T r i I n s e r t i o n ( L ) :
for i in range (1 , len (L )) :
a=L [ i ]
j=i
w h i l e j >0 and L [ j −1] > a :
L [ j ]=L [ j −1]
j=j −1
L [ j ]= a
return L
5SJ SBQJEF
Ce tri est un tri récursif. Il utilise une étape intermédiaire, appelée

partition, que nous détaillons tout d’abord. Cette étape a pour but,
étant donné un élément de la liste G appelé pivot, de répartir avant et
après le pivot les éléments de G respectivement inférieurs et stricte-
ment supérieurs au pivot.
Rje
136
Pour faire
faire cela,
cela, on
on commence
commencepar paréchanger
échangerlelepivot
pivotavec
aveclelepremier
premier
élément de G.
élément de G. On
On parcourt
parcourtensuite
ensuiteles élémentsdedeG.G.SiSionontrouve
leséléments trouve
un élément
élément inférieur
inférieur ou
ouégal
égalauaupivot,
pivot,ononéchange
échangelelepivot
pivotavec
aveccetcet
élément
élément puis
puis le
lepivot
pivotavec
avecl’élément
l’élémentprécédemment
précédemmentà àdroite
droite dudupivot.
pivot.
On peut
peut représenter
représenterun unexemple
exemplede decette
cetteopération
opérationavec
aveclesles
diagrammes
diagrammes
suivants
suivants (on
(on aa déjà
déjà considérés
considéréslele44etetlele6,6,que
quel’on
l’ona alaissés
laissésà leur
à leur
place car
car ils
ils sont
sontstrictement
strictementsupérieurs
supérieursauaupivotpivot3)3): :
On donne
donne maintenant
maintenantl’algorithme
l’algorithmededelalapartition
partition: :
-hBMHPSJUINF
-hBMHPSJUINF
Fonction PPaarrtti itti ioonn((LL, ,pp) )
Fonction
Donnees
Donnees
L : ll ii ss tt ee dd‘‘ eenntti ieerrss , ,
p , i , jj :: eennttiieerrss
Debut
Debut
LL [[ 00]] ,,LL[[pp]] <−−
<−− LL[ [pp] ], ,LL[ 0[ 0] ]
ii <−−
<−− 00
Pour jj vvaarri iaanntt de
Pour de 11 àà l el enn( L( L) )
FFaaiirree
SSii LL[[ jj]<=L
]<=L[ [i i] ]
AAlloorrss
LL[[ i i ]], , LL[ [j j] ] <−−
<−− LL[ [j j] ], , L L[ i[ ]i ]
LL[[ jj]], , LL[ [i i+1]+1] <−−
<−−LL[ [i +1] i +1], , L L [ j[ ]j ]
ii <−−
<−− i i+1 +1
Fin
Fin SSii
Fin
Fin FFaaiirree
Retourner ((LL, ,i i))
Retourner
Fin
Rjd
Rjd
137
G et un indice p appelé position du pivot. Elle retourne la liste obtenue

en plaçant avant le pivot G(T) tous ceux qui lui sont inférieurs et après
lui tous ceux qui lui sont strictement supérieurs. On retourne de plus
l’indice correspondant à la position dans cette nouvelle liste du pivot.
Terminaison : On a ici une boucle inconditionnelle terminant en
H2MUGV@R itérations.
Correction : On a l’invariant de boucle : "les éléments d’indice
inférieur à i sont inférieurs ou égaux à G(B) et G(B) est égal au pivot".

Complexité : On note n la longueur de la liste. On a au pire 3 +
7n OPEL dans cet algorithme.
def P a r t i t i o n ( L , p ) :
L[0] , L[p] = L[p] , L[0]
i = 0
for j in range (1 , len (L )) :
i f L [ j ] <= L [ i ] :
L[ i ] , L[ j ] = L[ j ] , L[ i ]
L [ j ] , L [ i +1] = L [ i +1] , L [ j ]
i = i +1
return (L , i )
On peut maintenant détailler l’algorithme du tri rapide.
L’idée est choisir un pivot, effectuer la partition correspondant, puis

recommencer l’opération sur les deux listes formées par les éléments
situés d’une part avant et d’autre part après le pivot.
Comme tout algorithme récursif il est primordial de préciser le cas
d’arrêt de l’algorithme. On s’arrête ici si la liste considérée contient
un ou aucun élément.
On présente sur les diagrammes suivants une réalisation de cet algo-
rithme. Les pivots choisis sont en gris les éléments fixés en foncé.
Rj3
138
L’algorithme s’arrête ici car les listes sur lesquelles on devrait refaire
l’opération sont de longueur inférieure ou égale à 1.
Nous choisissons ici la position du pivot au hasard dans la partie de
liste considérée. On effectuera ce tirage au hasard en python à l’aide
de la fonction `/X`M/BMiUV de la bibliothèque `M/QK. On pourrait
aussi prendre systématiquement le premier ou le dernier élément.
-hBMHPSJUINF
Fonction T r i R a p i d e ( L )
Donnees
L , L1 , L2 : l i s t e d ‘ e n t i e r s ,
p, k : entiers
Debut
S i l e n ( L)<=1
Alors
Retourner ( L )
Sinon
p <−− e n t i e r au h a s a r d e n t r e 0 et l e n ( L )
L , k <−− P a r t i t i o n ( L , p )
L1 <−− T r i R a p i d e ( L [ 0 : k ] )
L2 <−− T r i R a p i d e ( L [ k +1 :])
Retourner L1+[L [ k ] ] + L2
Fin S i
Fin

et retourne la liste triée contenant les mêmes éléments que G.
Terminaison : Cette fonction est récursive, et à chaque applica-
tion elle se relance deux fois avec des listes de longueurs strictement
RjN
139
inférieures à celle de la liste donnée en entrée. L’arbre d’exécution
de cette fonction récursive est donc de hauteur au plus H2MUGV.
Correction : On démontre la correction de cet algorithme à l’aide
d’une récurrence forte.

Complexité : On note n la longueur de G. Dans le pire des cas,
la partition donne une des listes GR ou Gk vide et l’autre de longueur

H2MUGV@R. Si c’est le cas à chaque étape, on applique alors n-1 fois
Partition. Comme celle-ci est de complexité linéaire en n on obtient
une complexité totale quadratique en n dans le pire des cas.
On peut cependant montrer que la complexité en moyenne de cet
algorithme est de l’ordre de n HM(n).
def T r i R a p i d e ( L ) :
i f l e n ( L)<=1 :
return (L)
p = r d . r a n d i n t ( 0 , l e n ( L) −1)
L , k = P a r t i t i o n (L , p)
L1 = T r i R a p i d e ( L [ 0 : k ] )
L2 = T r i R a p i d e ( L [ k +1 :])
r e t u r n L1+[L [ k ] ] + L2
Il est également possible de réaliser cet algorithme en place, c’est-

à-dire en ne créant pas de listes intermédiaires en machine, mais en
faisant toutes les modifications dans la liste d’origine. On garde les
mêmes complexités que dans le cas traité précédemment.
def P a r t i t i o n 2 ( L , p , a , b ) :
L[a] , L[p] = L[p] , L[a]
i = a
f o r j i n r a n g e ( a +1,b+1) :
i f L [ j ] <= L [ i ] :
L[ i ] , L[ j ] = L[ j ] , L[ i ]
L [ j ] , L [ i +1] = L [ i +1] , L [ j ]
i = i +1
return ( i )
R9y
140
def T r i R a p i d e 2 ( L , a , b ) :
i f b−a>0 :
p = rd . r a n d i n t (a , b)
k = P a r t i t i o n 2 (L , p , a , b)
T r i R a p i d e 2 ( L , a , k −1)
T r i R a p i d e 2 ( L , k +1,b )
3FDIFSDIF SBQJEF EF MB NÏEJBOF
En s’inspirant de ce qui a été fait pour le tri rapide, on peut construire

un algorithme déterminant l’élément de rang k dans une liste G quel-
conque en temps linéaire. En particulier si le rang k en question est
la moitié de la longueur de la liste, on peut trouver la médiane d’une
liste en temps linéaire.
Comme pour le tri rapide, le principe est d’appliquer une partition
avec un pivot garantissant une répartition suffisamment bonne des
éléments de G autour de lui.
On commence par décrire une fonction déterminant ce bon pivot.
-hBMHPSJUINF
Fonction M e d i a n e L o c a l e ( L , a , b )
Donnees
L : liste d‘ entiers
a , b : entiers
Debut
Retourner T r i I n s e r t i o n ( L [ a :b + 1 ] ) [ ( b−a ) / / 2 ) ]
Fin
Fonction MedianeDesMedianes ( L )
Donnees
L , L1 : l i s t e s d ‘ e n t i e r s ,
i : entiers
Debut
Si l e n (L) < 5
R9R
141
Alors
Retourner ( M e d i a n e L o c a l e ( L , 0 , l e n ( L ) −1))
Sinon
L1 <−− [ ]
Pour i v a r i a n t de 0 à l e n ( L ) / / 5
Faire
L1 <−− L1+[ M e d i a n e L o c a l e ( L , 5 ∗ i , 5 ∗ i +4)]
Fin F a i r e
Retourner ( MedianeDesMedianes ( L1 ) )
Fin S i
Fin

G et retourne un nombre dont la position relative dans G n’est pas trop
éloignée de la mediane.
Terminaison : À chaque appel de la fonction, la longueur de la
liste considérée est divisée par 5, elle finira donc bien par être infé-
rieure à 5.
Correction : On découpe la liste considérée en tronçons de lon-
gueur 5 sur lesquels on calcule la médiane. On recommence alors
l’opération sur la liste de médianes obtenue. On peut montrer que
l’on garantit ainsi l’obtention d’un pivot permettant au pire de parti-
tionner la liste en deux parties contenant au moins 30 % de la liste.
def M e d i a n e L o c a l e ( L , a , b ) :
r e t u r n T r i I n s e r t i o n ( L [ a :b + 1 ] ) [ ( b−a ) / / 2 ]
def MedianeDesMedianes ( L ) :
i f l e n ( L)<5 :
r e t u r n M e d i a n e L o c a l e ( L , 0 , l e n ( L) −1)
L1 = [ ]
for i in range (0 , len (L)//5) :
L1=L1+[ M e d i a n e L o c a l e ( L , 5 ∗ i , 5 ∗ i +4)]
r e t u r n MedianeDesMedianes ( L1 )
R9k
142
On peut maintenant écrire l’algorithme de recherche d’un élément de
rang fixé. On utilisera pour cela les fonctions J2/BM2.2bJ2/BM2b
et SìBiBQMk.
-hBMHPSJUINF
Fonction ElementRangk ( L , a , b , k )
Donnees
L, : l i s t e d ‘ entiers ,
a , b, k, i , m : entiers
Debut
m <−− MedianeDesMedianes ( L [ a :b +1])
i <−− 0
Tant Que L [ i ] != m
Faire
i <−− i + 1
Fin F a i r e
p <−− P a r t i t i o n 2 ( L , i , a , b , )
S i k == p
Alors
Retourner ( L [ k ] )
Fin SI
Si k < p
Alors
Retourner ( ElementRangk ( L , a , p −1, k ) )
Sinon
Retourner ( ElementRangk ( L , p+1,b , k ) )
Fin S i
Fin

G, des indices a, b et k et retourne l’élément de rang k dans G.
tion elle se relance avec de nouveaux indices a et b tels que la nou-
velle valeur de b − a soit strictement inférieure à l’ancienne. Comme
b − a est entier, l’algorithme termine donc bien.
R9j
143
Correction : La définition de la fonction SìBiBQMk assure que
l’élément de rang k est toujours entre les a et b utilisés dans les appels
à la fonction, ce qui garantit la correction de l’algorithme.
Complexité : C’est ici délicat. On admettra que la complexité
obtenue est linéaire en la longueur de la liste G.
5SJ 'VTJPO
Ce tri est un également un tri récursif, comme le tri rapide. Il uti-

lise également une étape intermédiaire, appelée cette fois-ci fusion,
que nous détaillons en premier. Cette étape a pour but, étant données
deux listes triées, de construire la liste triée formées par les éléments
des deux listes.
Pour faire cela, on utilise deux indices parcourant chaque liste, et
suivant la comparaison des éléments correspondant on ajoute à une
nouvelle liste le plus petit des deux. On augmente alors de un l’indice
dans la liste dans laquelle on a choisi l’élément. En répétant cette
opération, on finit par vider une des deux listes. Il ne reste plus qu’à
ajouter les éléments restant à parcourir dans l’autre liste.
-hBMHPSJUINF
Fonction F u s i o n ( L1 , L2 )
Donnees
L , L1 , L2 : l i s t e s d ‘ e n t i e r s ,
i , j : entiers
Debut
L <−− [ ]
i <−− 0
j <−− 0
Tant Que i < l e n ( L1 ) et j < l e n ( L2 )
Faire
S i L1 [ i ] < L2 [ j ]
Alors
L <−− L + [ L1 [ i ] ]
i <−− i + 1
R99
144
Sinon
L <−− L + [ L2 [ j ] ]
j <−− j + 1
Fin SI
Retourner ( L+L1 [ i :]+L2 [ j : ] )
Fin

Spécification : Cette fonction prend en entrée deux listes d’en-
tiers GR et Gk triées. Il retourne la liste triée obtenue en regroupant
les éléments de GR et Gk en une seule liste.
Terminaison : La suite formée par les valeurs successives de i+j
à chaque itération de la boucle Tant Que est à valeurs entières et stric-
tement croissante. Par conséquent, si la boucle ne s’arrête pas aupa-
ravant elle prendra la valeur kKBMUH2MUGRV-H2MUGkVV. Or i et j étant
positifs si i+j vaut kKBMUH2MUGRV-H2MUGkVV c’est que i est supérieur à
H2MUGRV ou que j est supérieur ou égal à H2MUGkV, donc que la boucle
s’arrête si elle ne l’a pas déjà fait.
Correction : Un invariant de boucle est donné par : "Les élé-
ments de G constituent une liste triée et sont tous inférieurs à ceux
d’indices supérieurs à i dans GR et supérieurs à j dans Gk". Donc à
la sortie de la boucle, comme L1[i :] ou L2[j :] est vide, il suffit de
rajouter les deux pour que G contienne tous les éléments de GR et de
L2 et soit triée.
Complexité : On note n1 et n2 les longueurs des listes GR et Gk.
On a au pire, c’est-à-dire dans le cas où on effectue n1 + n2 − 1
passages dans la boucle 4+5(n2+n1−1) OPEL dans cet algorithme.
def F u s i o n ( L1 , L2 ) :
L=[]
i = 0
j = 0
w h i l e i < l e n ( L1 ) and j < l e n ( L2 ) :
i f L1 [ i ] < L2 [ j ] :
R98
145
L = L+[L1 [ i ] ]
i = i +1
else :
L = L+[L2 [ j ] ]
j=j +1
r e t u r n L+L1 [ i :]+L2 [ j : ]
On peut maintenant décrire l’algorithme du tri fusion. L’idée est de

dire que l’on peut trier une liste en triant la première moitié de la
liste ainsi que la deuxième puis de fusionner les deux listes triées
obtenues. Comme dans le cas du tri rapide, le cas d’arrêt de cet algo-
rithme est le cas d’une liste de longueur inférieure ou égale à 1, où il
n’y a rien à faire.
On peut illustrer cet algorithme en donnant le diagramme suivant :
-hBMHPSJUINF
Fonction T r i F u s i o n ( L )
Donnees
L , L1 , L2 : l i s t e d ‘ e n t i e r s ,
p, k : entiers
Debut
S i l e n ( L)<=1
R9e
146
Alors
Retourner ( L )
Sinon
L1 = T r i F u s i o n ( L [ 0 , l e n ( L ) / / 2 ] )
L2 = T r i F u s i o n ( L [ l e n ( L ) / / 2 : ] )
Retourner F u s i o n ( L1 , L2 )
Fin S i
Fin

et retourne la liste triée contenant les mêmes éléments que G.
tion elle se relance deux fois avec des listes de longueurs la moitié de
celle de G. L’arbre d’exécution de cette fonction récursive est donc
de hauteur au plus HQ;2 (len(L)).
Correction : On démontre la correction de cet algorithme à l’aide
d’une récurrence forte sur la longueur de la liste.
Complexité : Si on note Kn la complexité de cet algorithme pour
une liste de longueur n dans le pire des cas, on voit aisément que l’on
a la relation de récurrence suivante pour tout entier naturel n :
K2n = 2Kn + O(n).
On en déduit que K2n est de l’ordre de n HM(n) puis par encadrement

dans le cas général on obtient que la complexité totale est de l’ordre
de n HM(n) dans le pire des cas.
def T r i F u s i o n ( L ) :
i f l e n ( L)<=1 :
return (L)
L1 = T r i F u s i o n ( L [ 0 , l e n ( L ) / / 2 ] )
L2 = T r i F u s i o n ( L [ l e n ( L ) / / 2 : ] )
r e t u r n F u s i o n ( L1 , L2 )
R9d
147
Pour terminer sur le tri fusion on donne des fonction P YTHON per-
mettant d’appliquer cet algorithme en place, en ne créant pas de
listes intermédiaires en machine, mais en faisant toutes les modifi-
cations dans la liste d’origine. Contrairement au tri rapide on perd
beaucoup en complexité en faisant ce changement, et on n’obtient
qu’un algorithme quadratique en la longueur de la liste.
def F u s i o n E n P l a c e ( L , a , b , c , d ) :
i=a
j=c
w h i l e i <=j −1 and j <=d :
i f L [ i ]<=L [ j ] :
i +=1
else :
k=j
w h i l e k>i :
L [ k −1] , L [ k]=L [ k ] , L [ k −1]
k=k−1
i=i +1
j=j +1
return L
def T r i F u s i o n ( L , a , b ) :
i f b−a<=0 :
return L
else :
return FusionEnPlace ( TriFusion (

T r i F u s i o n ( L , a , ( a+b ) / / 2 ) , ( a+b )//2+1 , b ) ,

a , ( a+b ) / / 2 , ( a+b )//2+1 , b )
"VUSFT USJT
On présente dans cette partie trois autres algorithmes de tri. S’ils

ne sont pas explicitement au programme, ils restent incontournables
dans le domaine.
Le premier est le tri sélection. Il utilise une fonction calculant l’indice
R93
148
du minimum d’une liste (où le premier indice en lequel on le trouve).
L’idée de l’algorithme est alors de construire la liste triée en ajoutant
le minimum de ce qui reste à trier à chaque étape.
-hBMHPSJUINF
Fonction IndiceMinimum ( L , a , b )
Donnees
a , b , m, i : e n t i e r s
Debut
m <−− a
Pour i v a r i a n t de a+1 à b+1
Faire
S i L [ i ] < L [m]
Alors
m <−− i
Fin S i
Fin F a i r e
Retourner (m)
Fin
Fonction T r i S e l e c t i o n ( L )
Donnees
L : l i s t e d ’ entiers ,
i , m : entier
Debut
Pour i de 0 \ ‘ a l e n ( L )
Faire
m <−− IndiceMinimum ( L , i , l e n ( L) −1)
L [ i ] , L [m] <−− L [m] , L [ i ]
Fin Fai re
Retourner (L)
Fin

G et retourne la liste triée contenant les mêmes éléments que G.
R9N
149
Terminaison : La boucle inconditionnelle termine après len(L)
itérations.
Correction : On a pour invariant de boucle : "la liste formée des
éléments de G d’indice strictement inférieur à i est triée et tous ses
éléments sont inférieurs ou égaux aux éléments de G d’indice supé-
rieur ou égal à i".
Complexité : On note n la longueur de la liste G. L’appel de la
fonction AM/B+2JBMBKmK avec des indices a et b effectue au pire 1 +

2(b − a) OPEL. Dans h`Ba2H2+iBQM on appelle cette fonction avec les
indices a allant de 0 à H2MUGV@R, ce qui donne au pire un total de
n−1

4 + 2(n − i) = 4n + n(n + 1) = n2 + 5n
i=0
OPEL. Cet algorithme est donc de complexité quadratique en n.
def IndiceMinimum ( L , a , b ) :
m = a
f o r i i n r a n g e ( a +1, b+1) :
i f L [ i ] < L [m] :
m = i
return m
def T r i S e l e c t i o n ( L ) :
m = IndiceMinimum ( L , i , l e n ( L) −1)
L [ i ] , L [m] = L [m] , L [ i ]
return (L)
On présente ensuite le tri bulles. L’idée est de balayer la liste en

échangeant deux éléments côte-à-côte si ils ne sont pas bien ordon-
nés. On répète les balayages jusqu’à ne plus effectuer d’échange, ce
qui signifie que la liste est triée.
R8y
150
-hBMHPSJUINF
Fonction T r i B u l l e s ( L )
Donnees
b : booléen
i ,m : e n t i e r
Debut
b <−− V r a i
m <−− l e n ( L)−1
Tant Que b
Faire
b <−− Faux
Pour i v a r i a n t de 0 à m
Faire
S i L [ i ] > L [ i +1]
Alors
L [ i ] , L [ i +1] <−− L [ i +1] , L [ i ]
b <−− V r a i
m <−− i +1
Fin S i
Fin F a i r e
Fin F a i r e
Retourner ( L )
Fin

Terminaison : On peut montrer que tant que la liste n’est pas
triée la suite formée par les valeurs successives de la variables m à
chaque itération de la boucle Tant Que est strictement décroissante
et à valeurs entières. Si m prend la valeur 1 alors la liste est triée car
le dernier échange a eu lieu entre les indices 1 et 2. On en conclut
que la liste devient bien triée au bout d’au plus len(L) itérations, et
que la boucle Tant Que termine donc.
Correction : On a l’invariant de boucle suivant pour la boucle
Tant Que : "en début de boucle, les éléments de G d’indice supérieur
R8R
151
ou égal à la valeur de m forment une liste triée et sont tous supérieurs
ou égaux aux éléments d’indices strictement inférieurs à m"
Complexité : On note n la longueur de G. Dans le pire des cas,
la liste G est triée dans le sens inverse. L’algorithme effectue alors
n passages dans la boucle Tant Que, m prend successivement les
valeurs de n − 1 à 1, et hormis lors du dernier passage, le test du Si
est toujours vérifié. On en déduit que l’on effectue :
n−1

3+n+ 6m + n = 3 + 2n + 3n(n − 1) = 3n2 − n + 3
m=1
OPEL au total. Cet algorithme est donc de complexité quadratique

en n.
def T r i B u l l e s ( L ) :
b = True
m = l e n ( L)−1
while b :
b = False
f o r i i n r a n g e ( 0 ,m) :
i f L [ i ] > L [ i +1] :
L [ i ] , L [ i +1] = L [ i +1] , L [ i ]
b = True
m = i +1
return L
On termine enfin par un algorithme de complexité linéaire en la lon-

gueur de la liste, mais nécessitant de connaître un majorant des élé-
ments de la liste, et que celle-ci ne contienne que des entiers naturels.
L’idée est alors simplement de dénombrer les apparitions de chaque
entier pouvant être présent dans la liste, puis de reconstruire la liste
triée en les énumérant.
R8k
152
-hBMHPSJUINF
-hBMHPSJUINF
Fonction T TrriiEEnnuum meerraattiioonn((LL,M)
,M)
Donnees
L , L1 , L2 :: ll ii ss tt ee ss dd‘‘ eennttiieerrss ,,
i , j : e n tt ii ee rr ss
Debut
L1 <−−
<−− [[00 pour pour ii vvaarriiaanntt de de 00 àà M+1]
M+1]
Pour i vv aa rriiaanntt de de 00 àà lleenn((LL))
Faire
L1
L1 [[ LL [[ ii ]] ]] <−−
<−− L1 L1[[LL[[ ii ]]]]++11
Fin F aaiirree
L2 <−−
<−− [[ ]]
Pour i vv aa rriiaanntt de de 00 àà M+1 M+1
Faire
L2
L2 <−− <−− L2 L2 ++ [[ ii pourpour jj de de 00 àà L1
L1[ [i i] ]] ]
Fin F aaiirree
Retourner ((L2
Retourner L2))
Fin
Analyse de cet
cet algorithme
algorithme ::
Spécification Cette fonction
fonctionprend
prenden
enentrée
entréeune
uneliste
listed’entiers
d’entiers
naturels G et un
un entier
entier naturel
naturelMM majorant
majorantles
leséléments
élémentsdedeGGetetretourne
retourne
la liste triée contenant
contenant les
les mêmes
mêmes éléments queG.G.
élémentsque
Terminaison :: On
Terminaison On aa ici
icideux
deuxboucles
bouclesinconditionnelles
inconditionnellesde
delen(L)
len(L)
et M + 1 itérations
itérations respectivement.
respectivement.
Correction :: La
La première
première boucle
boucle terminée,
terminée,chaque
chaqueentrée
entréededeL1
L1
contient le nombre
nombre d’apparitions
d’apparitions de de l’indice
l’indicelui
luicorrespondant
correspondantdansdans
G. Il suffit donc
donc bien
bien de
de construire
construire L2 L2 comme
comme dans
dans lala deuxième
deuxième
boucle Pour pour
pour obtenir
obtenir la
la liste
liste triée
triéedes
deséléments deG.G.
élémentsde
Complexité :: On
Complexité On note
note nn lala longueur
longueurdedeG.
G.On
Oneffectue
effectueMM++11++
2n + 1 + n OPEL
OPEL au
au total.
total. À
ÀM M fixé,
fixé,l’algorithme
l’algorithmeest
estdonc
donclinéaire
linéaire
en n.
R8j
R8j
153
def T r i E n u m e r a t i o n ( L ,M) :
L1 = [ 0 f o r i i n r a n g e ( 0 , M+1)]
L1 [ L [ i ] ] = L1 [ L [ i ] ] + 1
L2 = [ ]
f o r i i n r a n g e ( 0 , M+1) :
L2 = L2 + [ i f o r j i n r a n g e ( 0 , L1 [ i ] ) ]
r e t u r n L2
$PNQBSBUJGT EFT EJGGÏSFOUT USJT
Pour clore ce chapitre, on donne une table de comparaison des algo-

rithmes rencontrés ici, et en particulier leur ordre de complexité dans
le pire et dans le meilleur des cas ainsi que leur ordre de complexité
en moyenne. On a laissé de côté le tri par énumération qui ne marche
pas dans un cas général.
On note à nouveau n la longueur de la liste considérée.
Complexité dans Complexité dans Complexité

le meilleur des cas le pire des cas en moyenne
tri insertion O(n) O(n2 ) O(n2 )
tri rapide O(n HM(n)) O(n2 ) O(n HM(n))
tri fusion O(n HM(n)) O(n HM(n)) O(n HM(n))
tri sélection O(n2 ) O(n2 ) O(n2 )
tri bulles O(n) O(n2 ) O(n2 )
#PÔUF Ë PVUJMT
Lorsque G est une liste de nombres, on peut directement obtenir la

liste triée en Python :
bQì2/UGV trie la liste L
R89
154
5SBJUFNFOU OVNÏSJRVF
5SBJUFNFOU OVNÏSJRVF
JNBHFT
EFT JNBHFT
3FQSÏTFOUBUJPO EFT
EFT JNBHFT
JNBHFT
En machine, les images

images sont
sont représentées
représentéespar pardes
desmatrices
matricesde denombres
nombres
ou de listes de nombres,
nombres, chacune
chacune desdes entrées
entrées de
de lala matrice
matrice codant
codant
un pixel. Quand l’image
l’image estest en
en niveaux
niveaux de de gris,
gris, les
les entrées
entrées sontsontdesdes
entiers compris entre 00 et et 255
255 (pouvant
(pouvant doncdonc être
être écrits
écrits sursur 88 bits),
bits),
le 0 correspondant à un un pixel
pixel noir
noir et
et le
le 255
255 àà un
un pixel
pixel blanc.
blanc.Quand
Quand
elle est en couleur, l’entrée
l’entrée est
est un
un triplet
triplet [R,G,B]
[R,G,B] d’entiers
d’entiersentreentre00etet
255 codant chacun l’intensité
l’intensité du
du pixel
pixel enen rouge,
rouge, vert
vert etet bleu
bleurespec-
respec-
tivement.
Pour récupérer la matrice
matrice correspondant
correspondant àà une
une image
image ainsi
ainsique
quecréer
créer
une image à partir d’une
d’une matrice,
matrice, on
on utilisera
utilisera les
les modules
modules Numpy
Numpy
(pour les matrices) et SAG,
SAG, et
et plus
plus particulièrement
particulièrement lele sous-module
sous-module
AK;2 de SAG.
Ainsi, une fois ces modules
modules importés
importés les
les instructions
instructions::
im=Image . open ( ’ image
image ..bmp
bmp ’’ ))
M=np . a r r a y ( im )
permettent de récupérer
récupérer dans
dans M
M lala matrice
matrice correspondant
correspondant ààl’image
l’image
du fichier image.bmp et
et les
les instructions
instructions
im = Image . f r o m aarrrraayy (M)(M)
im . s a v e ( ’ image . bmp
bmp ’’ ))
permettent de sauvegarder
sauvegarder l’image
l’image correspondant
correspondant àà lala matrice
matrice MM
dans un fichier image.bmp.
image.bmp. À À noter
noter que
que les
les nombres
nombres apparaissant
apparaissant
dans M doivent être codés
codés en
en uint8,
uint8, ce
ce qui
qui s’assure
s’assure en
en créant
créant lala
matrice avec MTX``vU -MTXmBMi3V.
-MTXmBMi3V.
R88
R88
155
Terminons en précisant qu’une image im dans P YTHON peut être
affichée à l’écran avec l’instruction
im . show ( )
1SFNJÒSFT NBOJQVMBUJPOT
On donne ici quelques exemples de manipulations d’images. Dans

l’ordre, on écrit des fonctions permettant d’appliquer une symétrie
horizontale, une symétrie verticale, une rotation d’un quart de tour.
On prendra en entrée la matrice M correspondant à l’image.
def S y m e t r i e H o r i z o n t a l e (M) :
m = l e n (M)
n = l e n (M[ 0 ] )
M2 = np . a r r a y ( [ [ [ 0 , 0 , 0 ] f o r i i n r a n g e ( 0 , n ) ]

f o r m i n r a n g e ( 0 ,m) ] , np . u i n t 8 )
f o r i i n r a n g e ( 0 ,m) :
for j in range (0 , n) :
M2[ i , j ] = M[m−1−i , j ]
r e t u r n (M2)
def S y m e t r i e V e r t i c a l e (M) :
m = l e n (M)
n = l e n (M[ 0 ] )

f o r m i n r a n g e ( 0 ,m) ] , np . u i n t 8 )
f o r i i n r a n g e ( 0 ,m) :
M2[ i , j ] = M[ i , n−1− j ]
r e t u r n (M2)
def R o t a t i o n Q u a r t D e T o u r (M) :
m = l e n (M)
n = l e n (M[ 0 ] )

f o r m i n r a n g e ( 0 , n ) ] , np . u i n t 8 )
for i in range (0 , n) :
f o r j i n r a n g e ( 0 ,m) :
R8e
156
M2[ i , j ] = M[ j , n−1− i ]
r e t u r n (M2)
On peut également construire une fonction redonnant une image en

niveaux de gris correspondant à une image prise en couleurs. On
prendra en entrée a et b et c tels qu’un pixel codé par [R, G, B] soit
remplacé par
1
(aR + bG + cB)
a+b+c
en niveaux de gris. En pratique, le choix a = b = c = 1 ne donne pas
le meilleur rendu. On pourra préférer a = 0.2126 , b = 0.7152 et
c = 0.0722 (norme Rec. 709).
def N i v e a u x D e G r i s (M, a , b , c ) :
m = l e n (M)
n = l e n (M[ 0 ] )
M2 = np . a r r a y ( [ [ 0 f o r j i n r a n g e ( 0 , n ) ]

f o r i i n r a n g e ( 0 ,m) ] , np . u i n t 8 )
f o r i i n r a n g e ( 0 ,m) :
M2[ i , j ] = np . u i n t 8 ( ( a ∗M[ i , j ] [ 0 ] +

b∗M[ i , j ] [ 1 ] + c ∗M[ i , j ] [ 2 ] ) / ( a+b+c ) )
r e t u r n (M2)
3FDIFSDIF OBÕWF EF DPOUPVST
Pour rechercher les contours existant dans une image, on peut utiliser
une première approche simple en marquant les points en lesquels les
changements des valeurs codant les pixels sont importants. Pour cela,
on calcule la somme des valeurs absolues des différences des entiers
de pi,j avec tous les pixels l’environnant. On marquera alors le pixel
en noir si le résultat dépasse un seuil que l’on s’est fixé à l’avance.
Pour simplifier le parcours, on ne considèrera que les pixels inté-
rieurs à l’image considérée.
R8d
157
def C o n t o u r s (M, S ) :
m=l e n (M)
n=l e n (M[ 0 ] )
M2=np . z e r o s ( (m, n ) , np . u i n t 8 )
f o r i i n r a n g e ( 1 ,m−1) :
print ( i )
f o r j i n r a n g e ( 1 , n−1) :
G=0
for a in range (0 ,3) :
for b in range (0 ,3) :
for k in range (0 ,3) :
G=G+a b s (M[ i , j ] [ k ]

−M[ i −1+a , j −1+b ] [ k ] )
i f G>S :
M2[ i , j ]=255
r e t u r n (M2)
5SBJUFNFOU QBS DPOWPMVUJPO
Le procédé de traitement d’image proposé ici permet d’effectuer de

nombreuses modifications différentes sur des images, tout en adop-
tant une démarche générale.
Le principe est d’utiliser un noyau de convolution, c’est-à-dire une
matrice que nous prendrons dans notre cas comme carrée d’ordre 3,
donc de la forme : ⎛ ⎞
a 1 a2 a 3
⎝ a4 a5 a 6 ⎠
a7 a8 a 9
et de remplacer chaque pixel pi,j par :
a1 pi−1,j−1 +a2 pi−1,j +a3 pi1 ,j+1

+ a4 pi,j−1 +a5 pi,j +a6 pi,j+1
+ a7 pi+1,j−1 +a8 pi+1,j +a9 pi+1,j+1
R83
158
Suivant le noyau de convolution choisi, l’effet obtenu sur l’image
peut être très varié. Commençons par écrire des fonctions P YTHON
appliquant ce procédé. On utilisera une fonction intermédiaire modi-
fiant simplement un pixel étant donné la matrice de convolution N .
On prendra N à coefficients entiers et on utilisera un éventuel divi-
seur d après le calcul effectué avec N de façon à faire un maximum
de calculs avec des entiers.
Il faut se fixer une convention pour le travail sur le bord de l’image.
On utilisera ici les pixels du bord opposé pour le calcul, on pourrait
aussi simplement enlever les pixels du bord.
def C o n v o l u t i o n L o c a l e ( i , j ,M, N, d ) :

f o r a i n r a n g e ( 0 , l e n (M) ) ] , np . u i n t 8 )
S=np . a r r a y ( [ 0 , 0 , 0 ] )
for a in range (0 ,3) :
for b in range (0 ,3) :
S=S+(M[ i −1+a , j −1+b ] ∗N [ a , b ] ) / d
r e t u r n [ max ( min ( S [ 0 ] , 2 5 5 ) , 0 ) ,

max ( min ( S [ 1 ] , 2 5 5 ) , 0 ) , max ( min ( S [ 2 ] , 2 5 5 ) , 0 ) ]
def C o n v o l u t i o n (M, N, d ) :
m=l e n (M)
n=l e n (M[ 0 ] )
M=np . a r r a y ( [M[ − 1 ] ]

+[M[ k ] f o r k i n r a n g e ( 0 , l e n (M) ) ] )
M=np . a r r a y ( [ [M[ k ] [ − 1 ] ]

+ l i s t (M[ k ] ) f o r k i n r a n g e ( 0 , l e n (M) ) ] )
M=np . a r r a y ( [M[ k ] f o r k i n r a n g e ( 0 , l e n (M) ) ]

+[M[ 0 ] ] )
M=np . a r r a y ( [ l i s t (M[ k ] ) + [M[ k ] [ 0 ] ]

f o r k i n r a n g e ( 0 , l e n (M) ) ] )

f o r j i n r a n g e ( 0 ,m) ] )
f o r i i n r a n g e ( 1 ,m+1) :
print ( i )
f o r j i n r a n g e ( 1 , n+1) :
R8N
159
M2[ i −1, j −1] =

C o n v o l u t i o n L o c a l e ( i , j ,M, N, d )
r e t u r n M2
On peut alors, suivant l’effet voulu, prendre tel ou tel noyau. On

donne ici quelques exemples classiques :
• Floutage ou lissage
Pour flouter une image ou réduire un éventuel bruit on peut prendre
pour noyau la matrice :
⎛ ⎞
1 1 1
1⎝
1 1 1 ⎠
9
1 1 1
• Détection de contours
Pour faire ressortir les contours d’une image on peut prendre pour
noyau la matrice : ⎛ ⎞
0 1 0
⎝ 1 −4 1 ⎠
0 1 0
• Filtrage Gaussien
Pour essayer de faire disparaître un bruit naturel d’une image, on
peut prendre le noyau gaussien :
⎛ ⎞
1 2 1
1 ⎝
2 4 2 ⎠
16
1 2 1
« Les ordinateurs sont inutiles, ils ne nous donnent que des

réponses. »
1BCMP 1JDBTTP, artiste peintre espagnol.
Rey
160
$PEBHF FU USBOTNJTTJPO
"MHPSJUINFT EF DSZQUBHF ÏMÏNFOUBJSFT
Pour transmettre un message en évitant que quelqu’un l’interceptant

ne puisse en tirer profit, on utilise des méthodes de cryptage. Dans
l’idéal, seul quelqu’un connaissant la méthode utilisée et une clé de
décryptage pourra récupérer le message d’origine à partir du mes-
sage codé. De nombreuses méthodes ont été développées dans ce
but, certaines très savantes. Nous nous contentons ici d’en présenter
une, relativement élémentaire, le chiffrement de Vigenère. Dans la
suite, on utilisera le rang dans l’alphabet au sens de P YTHON (A sera
de rang 0).
Le principe est le suivant. On souhaite transmettre une chaîne de
caractères et pour la crypter nous allons définir une règle de substi-
tution associant à chaque caractère, suivant sa position dans le mes-
sage, un autre caractère. Pour simplifier nous nous contenterons de
prendre des messages écrits en majuscules et nous ne traiterons que
les lettres du message.
Pour fixer la règle de substitution, on fixe une clé qui sera un mot.
On note C ce mot et N sa longueur. On note Ri le rang dans l’al-
phabet de la j-ième lettre de C et ri le rang dans l’alphabet de la
lettre en i-ième position dans le message. Alors la lettre écrite dans
le message chiffré en i-ième position sera la lettre de rang le reste de
la division par 26 de ri + Rj si j est le reste de la division de i par N .
Un exemple sera plus parlant ! Si on prend C = "CAUCHY" et si on
souhaite coder "SCHWARZ" alors :
• Le S sera codé par la lettre de rang 18 (le rang de S dans l’alphabet)
plus 2 (le rang de C dans l’alphabet), soit 20.
ReR
161
• Le C sera codé par la lettre de rang 2 (le rang de C dans l’alphabet)
plus 0 (le rang de A dans l’alphabet), soit 2.
• Le H sera codé par la lettre de rang 7 (le rang de H dans l’alphabet)
plus 20 (le rang de U dans l’alphabet), soit 1 (on prend le reste de la
division de 27 par 26).
• Le W sera codé par la lettre de rang 22 (le rang de W dans l’alpha-
bet) plus 2 (le rang de C dans l’alphabet), soit 24.
• Le A sera codé par la lettre de rang 0 (le rang de A dans l’alphabet)
plus 7 (le rang de H dans l’alphabet), soit 7.
• Le R sera codé par la lettre de rang 17 (le rang de R dans l’alpha-
bet) plus 24 (le rang de Y dans l’alphabet), soit 15 (on prend le reste
de la division de 41 par 26)
• Le Z sera codé par la lettre de rang 25 (le rang de Z dans l’alpha-
bet) plus 2 (le rang de C dans l’alphabet) soit 1 (on prend le reste de
la division de 28 par 26).
Le message chiffré sera donc finalement "UCBYHPB".
On donne l’algorithme de chiffrement et les fonctions P YTHON pour
le chiffrement et le déchiffrement. Le déchiffrement se faisant sim-
plement en soustrayant le rang de la lettre de la clé au lieu de l’ajou-
ter.
-hBMHPSJUINF
Fonction C h i f f r e m e n t V i g e n e r e (M, C)
Donnees
M, C , M1 : c h a î n e s de c a r a c t è r e s ,
i , j , N : entiers
Debut
N <−− l e n (C)
M1 <−− " "
Pour i v a r i a n t de 0 à l e n (M)
Faire
M1 <−− M1 + C a r a c t e r e (

( Rang (M[ i ])+ Rang (C [ i%N] ) ) % 2 6 )
Fin F a i r e
Rek
162
Retourner M1
Retourner M1
Fin
Analyse de cet
cet algorithme
algorithme ::
Spécification
Cette fonction
fonction prend
prend en
en entrée
entréedeux
deuxchaînes
chaînesdede
caractères J et
et *
* et
et retourne
retourne le
le chiffrement
chiffrement de de Vigenère
Vigenèrede deJJen en
utilisant comme clé *.
comme clé *.
Terminaison :: La
Terminaison
La boucle
inconditionnellese setermine aprèsH2MUJV
termineaprès H2MUJV
itérations.
Complexité :: On
Complexité
On obtient
obtient une
une complexité
complexitélinéaire
linéaireen
enlalalongueur
longueur
de J.
-F
-F QSPHSBNNF
QSPHSBNNF FO
FO 1ZUIPO
1ZUIPO
On utilise ici les fonctions Q`/UV

les fonctions Q`/UV etet +?ÙV
+?ÙV de
de PPYTHON
YTHON. .LaLafonction
fonction
Q`/UV associe un
un entier
entier àà un
un caractère
caractère(avec
(avec6565pour
pourlelecaractère
caractère"A")
"A")
et la fonction +?ÙV
+?ÙV est
est le
le procédé
procédé réciproque
réciproquede deQ`/UV.
Q`/UV.
def C h i f f r ee m
meennttV
Viiggeenneerree (M,
(M,C) C) ::
N = l e nn (C) (C)
M1 = "" ""
f o r i iinn rraannggee ((00 ,, lleenn(M) (M))) ::
M1
M1 = = M1
M1 + + cchhrr (((((((( oorrdd(M[
(M[ i i ]])) ++
oorrdd(C(C[[ i%N]))
i%N]))−130)%26)+65)
−130)%26)+65)
r e t u r n M1 M1
4PNNFT EF DPOUSÙMF
DPOUSÙMF DPEFT
DPEFT DPSSFDUFVST
DPSSFDUFVST
Toujours dans le
le cadre
cadre de
de la
la transmission
transmission d’information,
d’information,on onconsi-
consi-
dère maintenant
maintenant un
un problème
problème un un peut
peut différent.
différent.Désormais,
Désormais,on onsou-
sou-
haite déterminer
déterminer si
si le
le message
message transmis
transmis aa été
étéaltéré
altéréet,
et,dans
dansl’idéal,
l’idéal,
on souhaite pouvoir
pouvoir retrouver
retrouver le le message
message initial
initialsisides
deserreurs
erreurssont
sont
apparues.
De façon à pouvoir
pouvoir repérer
repérer l’apparition
l’apparitiond’une
d’uneerreur,
erreur,ononvavaagrandir
agrandir
un peu le message
message en
en lui
lui ajoutant
ajoutantune
uneinformation
informationsur
sursasastructure.
structure.SiSi
Rej
Rej
163
le message est modifié
modifié on
on pourra
pourra repérer
repérerune
uneincohérence
incohérenceentre
entrecette
cette
information et la
la nouvelle
nouvelle structure
structureobtenue.
obtenue.
On se limitera àà un
un exemple
exemple très
très simple
simple de
de somme
sommede
decontrôle
contrôle: :lele
bit de parité.
On transmettra ici
ici un
un message
message enen binaire
binairesoussouslalaforme
formed’une
d’unechaîne
chaîne
de caractères. Si
Si le
le message
message est ...bnn on
est bb00...b on appelle
appelle bitbitde
deparité
parité
n+1 de
de
n+1
ce message le bitbit bbn+1
n+1 ∈ ∈ {0, 1} tel
{0,1} tel que
que lala somme
sommeSSnn == i=0 i=0bbii
soit paire. Le nouveau
nouveau message
message est
est alors
alors bb00...b
...bn+1
n+1 et
eton
on pourra
pourra dé-
dé-
tecter une erreur
erreur dans
dans lele message
message reçureçu sisi lala somme
sommeSSnnest estimpaire
impaire
(on détecte plus
plus généralement
généralement s’ils’il yyaaun unnombre
nombreimpairimpaird’erreurs).
d’erreurs).
-F
-F QSPHSBNNF
QSPHSBNNF FO
FO 1ZUIPO
1ZUIPO
On donne ici des

des fonctions
fonctions donnant
donnantlelemessage
messageobtenu
obtenuen
enajoutant
ajoutantlele
bit de parité ainsi
ainsi qu’une
qu’une fonction
fonction testant
testantlalasomme
sommededecontrôle.
contrôle.
def B i t D e P
P aarriittee (M)
(M) ::
S=0
f o r i iinn rraannggee ((00 ,, lleenn(M)
(M))) ::
S=S+i
S=S+i nn tt (M[ (M[ ii ]]))
return M M+s
+s tt rr ((S%2)
S%2)
def C o n t r oo ll ee P
Paarriittee (M)
(M) ::
S=0
f o r i iinn rraannggee ((00 ,, lleenn(M)
(M))) ::
S=S+i
S=S+i nn tt (M[ (M[ ii ]]))
i f S%2
S%2 == == 00 ::
r e ttuurrnn TrueTrue
else :
r e ttuurrnn FFaallssee
En utilisant ces fonctions,

fonctions,nous
nousallons
allonsmaintenant
maintenantdécrire
décrireune
uneméthode
méthode
permettant non seulement
seulement dededétecter
détectermais
maiségalement
égalementdedecorriger
corrigerune
une
(et une seule !) erreur.
erreur. Nous
Nous décrivons
décrivons ici
iciune
uneimplémentation
implémentationde decece
que l’on appelle le code
appelle le code de
de Hamming(4,7).
Hamming(4,7).Les Lescodes
codesdedeHamming
Hamming
forment une famille
famille dede codes
codes correcteurs
correcteursd’erreur
d’erreurlinéaires
linéairesque
quel’on
l’on
Re9
Re9
164
peut
peutconstruire
construireetetdécrire
décrirede
defaçon
façonplus
plus sophistiquée
sophistiquée que
que ce
ce que
que nous
faisons
faisonsdans
danscet
cetexemple
exemplesimple.
simple.
Nous
Nousconsidérons
considéronslalatransmission
transmission d’und’un message
message constitué
constitué de de quatre
quatre
bitsbb11bb22bb33bb44. . Le
bits Le message
message qui qui sera
sera transmis
transmis serasera constitué
constitué de de sept
bits.
bits.Nous
Nousallonsallonsen eneffet
effetrajouter
rajouterdes
desbits
bitsde
deparité
parité pp11,, pp22 et et pp33 corres-
corres-
pondant
pondantrespectivement
respectivementaux aux messages
messages bb11bb22bb44,, bb11bb33bb44 et
et bb22bb33bb44. Une
erreur
erreursursurun undes desbits
bitssera
seraindiquée
indiquée par
par le
le fait
fait qu’un
qu’un des des bit
bit dede parité
auaumoins
moinsne necorrespondra
correspondra pas. pas. De
De plus,
plus, la
la configuration
configuration des des bits
bits de
parité
paritéerronés
erronésprécise préciselalaposition
position dede l’erreur
l’erreur!! OnOn envoie
envoie en en pratique
pratique
lelemessage
messagepp11pp22bb11pp33bb22bb33bb44 car
car nous
nous verrons
verrons queque cette
cette configuration
configuration
permet
permetd’automatiser
d’automatiserleledécodage.
décodage.
Prenons
Prenonsun unexemple
exemple :: sisi nous
nous recevons
recevons le le message
message ’1111100’
’1111100’ alors
lelebit
bitde paritépp11 est
deparité estfaux,
faux, lele bit
bit de
de parité
parité p2
p2 est
est correct
correct et
et le
le bit de
parité
paritépp33est
estcorrect.
correct.Dans
Danscece cascas la
la seule
seule possibilité
possibilité est
est que
que l’erreur
l’erreur
(qui
(quidoit
doitêtre
êtreunique
unique!)!)aaeueulieu
lieusur
sur pp11!!
Pour
Pourdécoder
décoderefficacement
efficacementlelemessage
messageon on peut
peut recourir
recourir àà une
une matrice
matrice
de
decontrôle
contrôlepour
pource
cecode.
code.On
Ondéfinit
définit la
la matrice
matrice HH par
par ::
⎛
⎛ ⎞
⎞
00 00 00 11 11 11 11
H
H= ⎝ 00 11 11 00 00 11 11 ⎠
=⎝ ⎠..
11 00 11 00 11 00 11
On appelle syndrôme
On appelle syndrôme lele produit
produit de
de cette
cette matrice
matrice par
par la
la colonne
colonne
corespondant
corespondantau au message
message reçu.
reçu. Ainsi,
Ainsi, toujours
toujours avec
avec l’exemple
l’exemple pré-
cédent,
cédent,lelesyndrôme
syndrômesera
sera::
⎛ 11 ⎞
⎛ ⎞
⎛
⎛ ⎞
⎞ 11 ⎛⎛ ⎞ ⎞
00 00 00 11 11 11 11 ⎜ ⎜ 11 ⎟
⎟ 00
⎠⎜⎜ ⎟ ⎟ ⎝
⎝ 00 11 11 00 00 11 11 ⎠
ss==⎝ ⎜ 11 ⎟
⎜ ⎟== ⎝ 00 ⎠
⎠
⎝ 11 ⎠
⎝ ⎠
11 00 11 00 11 00 11 00 11
00
Re8
Re8
165
On peut remarquer que H a été construite⎛ de manière
⎞ à ce que ce
p1
produit donne comme résultat la colonne ⎝ p2 ⎠.
p3
Le positionnement des bits de parité dans le message fait que le syn-
drôme, interprété en binaire, donne le numéro du bit sur lequel une
erreur a été commise. Ainsi ici, (001)2 code 1 en binaire et l’erreur a
bien eu lieu sur le premier bit transmis, p1 .
On peut maintenant écrire des fonctions de codage et décodage pour
le code de Hamming(7,4).
def c o d a g e (M) :
p1 = B i t D e P a r i t e (M[ 0 ] +M[ 1 ] +M[ 3 ] ) [ − 1 ]
r e t u r n p1+p2+M[ 0 ] + p3+M[ 1 : ]
def d e c o d a g e (M) :
H = np . a r r a y ( [ [ 0 , 0 , 0 , 1 , 1 , 1 , 1 ] ,

[0 ,1 ,1 ,1 ,0 ,0 ,1 ,1] ,[1 ,0 ,1 ,0 ,1 ,0 ,1]])
X = np . a r r a y ( [ [ i n t (M[ i ] ) ] f o r i i n r a n g e ( 7 ) ] )
Y = np . d o t (H, X)
M1 = " "
for i in range (0 ,3) :
M1 = M1 + s t r (Y [ i , 0 ] % 2 )
a = i n t (M1, 2 )
i f a == 0 :
return M
M2=" "
for i in range (0 ,7) :
i f a == i + 1 :
M2 = M2 + s t r ( ( i n t (M[ i ])+1)%2)
else :
M2 = M2 + M[ i ]
r e t u r n M2
Ree
166
(SBQIFT
3FQSÏTFOUBUJPO EhVO HSBQIF
Un graphe est la donnée d’un couple (S, A) où S est un ensemble

dont les éléments sont appelés sommets du graphe et où A est un
ensemble de paires d’élements de A dont les éléments sont appelés
les arêtes du graphe. On peut représenter un tel objet comme sur la
figure suivante :
On appelle graphe orienté la donnée d’un couple (S, A) où S est un

ensemble dont les éléments sont appelés sommets du graphe et où A
est un ensemble de couples d’éléments de A dont les éléments sont
appelés les arcs du graphe. On obtient alors une figure comme :
Red
167
On dit qu’un graphe, orienté ou non, est pondéré si à chaque arête
ou arc du graphe est associé un nombre réel (généralement positif)
appelé poids de cet arc. Ce qui peut se représenter par :
Pour pouvoir travailler avec de tels objets, on associe à un graphe une

matrice, appelée matrice d’adjacence. À chaque sommet du graphe
on associe un indice i. Dans la matrice, on indique la présence ou
non d’un arc ou d’une arête entre deux sommets i et j en affectant à
aij la valeur 1 ou 0. Si le graphe est pondéré, on affecte plutôt à aij
le poids de l’arc partant de i et arrivant à j. Si un tel arc n’existe pas,
on pourra affecter ∞ à aij .
Re3
168
Dans le cas des graphes des trois figures précédentes, on obtient les
matrices suivantes :
⎛ ⎞
0 1 0 1 0 0 0
⎜ 1 0 1 1 1 0 0 ⎟
⎜ 0 1 0 0 1 0 0 ⎟
⎜ ⎟
⎜ 1 1 0 0 1 1 0 ⎟
⎜ ⎟
⎜ 0 1 1 1 0 1 1 ⎟
⎝ 0 0 0 1 1 0 1 ⎠
0 0 0 0 1 1 0
⎛ ⎞
0 0 0 0 0 0 0
⎜ 1 0 0 0 0 0 0 ⎟
⎜ 0 1 0 0 0 0 0 ⎟
⎜ ⎟
⎜ 1 1 0 0 0 0 0 ⎟
⎜ ⎟
⎜ 0 1 1 1 0 0 0 ⎟
⎝ 0 0 0 1 1 0 0 ⎠
0 0 0 0 1 1 0
⎛ ⎞
∞ ∞ ∞ ∞ ∞ ∞ ∞
⎜ 7 ∞ ∞ ∞ ∞ ∞ ∞ ⎟
⎜ ∞ 8 ∞ ∞ ∞ ∞ ∞ ⎟
⎜ ⎟
⎜ 5 9 ∞ ∞ ∞ ∞ ∞ ⎟
⎜ ⎟
⎜ ∞ 7 5 15 ∞ ∞ ∞ ⎟
⎝ ∞ ∞ ∞ 6 8 ∞ ∞ ⎠
∞ ∞ ∞ ∞ 9 11 ∞
"MHPSJUINF EF QMVT DPVSU DIFNJO
Un problème classique, étant donné un graphe, est de chercher à

déterminer le plus court chemin joignant deux sommets donnés. Dans
le cas d’un graphe pondéré, la longueur du chemin consistera en
la somme des poids des arcs ou arêtes parcourus. On présente ici
l’algorithme de Dijkstra, permettant de résoudre ce problème.
On décrira l’algorithme dans le cas d’un graphe orienté pondéré.
Expliquons rapidement le principe de l’algorithme. Supposons que
l’on cherche le plus court chemin joignant g à a. On va construire
une table dans laquelle à chaque sommet seront associés la longueur
ReN
169
du plus court chemin trouvé jusqu’ici menant à ce sommet depuis g
et le dernier sommet emprûnté pour ce chemin.
• On initialise la table à (0, g) pour g et (∞, x) pour le sommet x.
Le sommet g est donc considéré comme traité.
• On détermine le voisin non traité d’un des sommets traités le plus
proche de g en comparant les sommes pour chaque sommet non traité
s1 et chaque sommet traité s2 de la distance entre s1 et s2 et de la
distance stockée dans la table pour s2 .
• On associe au sommet s1 le plus proche trouvé dans l’étape précé-
dente la somme minimale obtenue et le sommet s2 pour lequel elle a
été obtenue.
• On détermine pour chaque sommet si déjà traité avant ce nouveau
sommet s1 si la somme de la longueur de l’arc le joignant à s1 et de
la distance stockée dans la table pour s1 est inférieure à la distance
stockée précédemment pour si . Si c’est le cas on écrit la somme dans
la table et y associe le sommet s1 .
• On recommence jusqu’à obtenir comme sommet le plus proche
le sommet cible, c’est-à-dire a ici, ou jusqu’à avoir traité tous les
sommets du graphe.
Pour écrire cet algorithme on utilisera ici plusieurs sous-fonctions.
• La fonction Dist déterminera la distance au sommet initial d’un
sommet s donné, obtenue en sommant les distances obtenue précé-
demment et la distance au sommet s correspondant.
• La fonction SHmbS`Q+?2 utilisera la fonction Dist pour déterminer
le sommet pour lequel on obtiendra la plus petite distance cumulée.
• La fonction 1MH2p2 permettra d’enlever un sommet de la liste des
sommets restant à traiter.
• La fonction *?2KBM donnera le chemin obtenu une fois la table
terminée.
• La fonction .BDFbi` appliquera l’algorithme.
On ne détaillera pas les algorithmes pour 1MH2p2 et *?2KBM, qui sont
très simples. On peut tout du moins remarquer qu’ils sont linéaires
en la taille de leurs entrées.
Rdy
170
-hBMHPSJUINF
-hBMHPSJUINF
Fonction D D iisstt (A
(A,, Table
Table ,, ss))
Donnees
A , T a b l e :: ll ii ss tt ee ss de
de lliisstteess
s , i : e n tt ii ee rr
Debut
d <−− [[ ii nn ff ii nn ii ,, 00]]
Pour i vv aa rriiaanntt de de 00 àà lleenn(A) (A)
Faire
Si T Taabbllee [[ ii ]][[11]] +
+ AA[[ ii ]][[ ss]] << dd[ [00] ]
A lloorrss
dd <−−
<−− [[ TTaabbllee [[ ii ]][[11]] ++ AA[ [i i ] ][ [ss] ], , i i] ]
Fin
Fin SSii
Fin F aaiirree
Retourner ((dd))
Retourner
Fin
Analyse de cet
cet algorithme
algorithme ::
fonctionprend
prenden entréeune
enentrée uneliste
listede
delistes
listes
décrivant la matrice
matrice d’adjacence
d’adjacence dudu graphe,
graphe,Table,
Table,une
uneliste
listededelistes
listes
contenant la table
table courante
courante pour
pourl’algorithme
l’algorithmede deDijkstra
Dijkstraetetssl’indice
l’indice
du sommet considéré.
considéré. Elle
Elle retourne
retourne lala somme
sommede dedistance
distanceminimale
minimale
obtenue pour le le sommet
sommet ss ainsi
ainsi que
que l’indice
l’indicedudusommet
sommetpourpourlequel
lequel
elle l’a été.
Terminaison :: La
Terminaison La boucle
inconditionnellese
setermine aprèsH2MUV
termineaprès H2MUV
itérations, c’est-à-dire
c’est-à-dire en
enautant
autantd’itérations
d’itérationsque
quede
desommets
sommetsdudugraphe.
graphe.
Complexité :: On
Complexité On obtient
obtient une
une complexité
complexitélinéaire
linéairepar
parrapport
rapportau
au
nombre de sommets
sommets du
du graphe.
graphe.
-hBMHPSJUINF
-hBMHPSJUINF
Fonction P PlluussP Prroocchhee (A
(A,, Table
Table ,,LL))
Donnees
A , T a b l e :: ll ii ss tt ee ss de
de lliisstteess
L : l i s t e dd ‘‘ ee nn tt iieerrss
i : entier
m i n i : t r i pp ll ee tt dede nombres
nombres
RdR
RdR
171
Debut
m i n i <−− L [ 0 ] , i n f i n i , L [ 0 ]
Faire
[ d , p ] <−− D i s t (A , Table , L [ i ] )
Si d < mini [ 1 ]
Alors
m i n i <−− [ L [ i ] , d , p ]
FIn S i
Fin F a i r e
Retourner ( m i n i )
Fin

Spécification : Cette fonction prend en entrée une liste de listes
décrivant la matrice d’adjacence du graphe, h#H2, une liste de listes
contenant la table courante pour l’algorithme de Dijkstra, G une liste
d’entiers donnant la liste des sommets restant à traiter. Elle donne
comme résultat un triplet donnant le voisin pour lequel le nouveau
sommet a été trouvé, la somme de distance correspondant, et le nou-
veau sommet.
Terminaison : La boucle inconditionnelle termine en H2MUGV ité-
rations, c’est-à-dire en autant d’itérations que de sommets du graphe
restant à traiter.
Complexité : En utilisant la complexité obtenue pour .Bbi, on
obtient une complexité au pire linéaire en le produit du nombre de

sommets du graphe et le nombre de sommets du graphe restant à
traiter.
-hBMHPSJUINF
Fonction D i j k s t r a (A , a , b )
Donnees
A , T a b l e : l i s t e s de l i s t e s ,
a , b, i , j : entiers
m i n i : t r i p l e t de nombres
Rdk
172
Debut
n <−−
<−− lleenn (A) (A)
T aabbllee <−−
<−− [[[[aa,, i innf fi inni i] ] pour pour i i dede 0 0 à à n n] ]
T aabbllee [[ aa]] <−−
<−− [[aa, , 00] ]
L <−−[k
<−−[k pour pour kk de de 00 àà aa] + ] +[ k[ k pour
pour k k dede a+1 a+1à àn ]n ]
Pour ii vvaarriiaanntt de
Pour de 11 àà nn
F aaiirree
mmiinnii <−−<−− PPl luussPPrroocchhee(A (A, , Table
Table, , L L) )
TTaabbllee((m miinni i [[00] ]] ] <−−
<−− [ [mmi ni ni i[ 2[ 2] ], , mmi ni ni [i 1[ 1] ]] ]
Pour jj vvaarri iaanntt de
Pour de 00 àà nn
FFaaiirree
SSii TTaabbl lee[ [mmi ni ni i[ [00] ] ][ [11] ] ++AA[ m [ mi ni n
i [i 0[ 0] ]] [] j[ ]j ]

<< TTaabbl lee[ [j j] ][ [11] ]
AAlloorrss
TTaabbl lee[ [j j] ][ [11] ] <−−
<−− TTa ab bl el e[ m[ mi ni in[i 0[ ]0]][]1[ ]1+] +

AA[[mmi inni i[ [00] ] ][ [j j] ]
TTaabbl lee[ [j j] ][ [00] ] <−−
<−− mmi ni ni [i 0[ 0] ]
Fin
Fin SSi i
Fin
Fin FFaaiirree
SSii m miinnii [[00]] == == bb
AAlloorrss
Retourner((Chemin
Retourner Chemin( (Table Table, a, a, b, b) ) )
LL <−−
<−− EEnnl leevvee((LL, , mmi ni ni i[ [00] )] )
Fin
Fin FFaaiirree
Fin
Analyse
Analyse de
de cet
cet algorithme
algorithme ::
fonctionprend entréeune
prendenenentrée uneliste
listededelistes
listes
décrivant
décrivant la
la matrice
matriced’adjacence
d’adjacencedu dugraphe,
graphe,ainsi
ainsique
queleslesindices
indicesa aetet
b des sommets
sommets prispris comme
commepoints
pointsde
dedépart
départetetd’arrivée
d’arrivéeduducheminchemin
cherché.
cherché. Elle
Elle donne
donne comme
commerésultat
résultatlalalongueur
longueurduduchemin
cheminleleplus plus
court reliant
reliant les
les deux
deux sommets
sommetschoisis
choisisainsi
ainsique
quelalaliste
listedes
desindices
indices
des sommets
sommets parcourus
parcourussursurce
cechemin.
chemin.
Terminaison :: Les
Terminaison Les boucles
bouclesinconditionnelles
inconditionnellesseseterminent
terminentenenn n
itérations,
itérations, c’est-à-dire
c’est-à-direen
enautant
autantd’itérations
d’itérationsque
quededesommets
sommetsdudugraphe.
graphe.
Correction :: On
Correction Onaal’invariant
l’invariantde
deboucle
boucle: :««Les
Lesdistances
distancesstockées
stockées
dans la table
table sont
sont les
les distances
distancesminimales
minimalesauausommet
sommetinitial
initialpour
pourlele
Rdj
Rdj
173
sous-graphe des sommets déjà traités ».
Complexité : On ne rentrera pas dans le détail, mais on obtient
un algorithme polynomial en le nombre de sommets et le nombre

d’arcs du graphe.
On utilise ici l’infini de P YTHON, donné par float("inf"). On écrira

donc au préalable dans le programme inf = float("inf").
def D i s t (A , Table , s ) :
d=i n f , 0
f o r i i n r a n g e ( 0 , l e n (A ) ) :
i f Table [ i ] [ 1 ] +A[ i ] [ s ] < d [ 0 ] :
d = Table [ i ] [ 1 ] +A[ i ] [ s ] , i
return d
def P l u s P r o c h e (A , Table , L ) :
m i n i=L [ 0 ] , i n f , L [ 0 ]
for i in L :
d , p = D i s t (A , Table , i )
i f d<m i n i [ 1 ] :
mini = i , d , p
return mini
def E n l e v e ( L , i ) :
L1 = [ ]
for j in range (0 , len (L )) :
i f L [ j ] != i :
L1=L1+[L [ j ] ]
r e t u r n L1
def Chemin ( Table , a , b ) :

L=[ T a b l e [ b ] [ 0 ] , b ]
w h i l e L [ 0 ] != a :
L=[ T a b l e [ L [ 0 ] ] [ 0 ] ] + L
return Table [ b ] [ 1 ] , L
Rd9
174
def D i j k s t r a (A , a , b ) :
n = l e n (A)
Table = [ [ a , i n f ] for i in range (0 , n ) ]
Table [ a ] = [ a , 0 ]
L = [ k f o r k i n r a n g e ( 0 , a )]+

[ k f o r k i n r a n g e ( a +1,n ) ]
m i n i = P l u s P r o c h e (A , Table , L )
Table [ mini [ 0 ] ] = [ mini [ 2 ] , mini [ 1 ] ]
i f Table [ mini [ 0 ] ] [ 1 ] + A[ mini [ 0 ] ] [ i ]

< Table [ i ] [ 1 ] :
Table [ i ] [ 1 ] = Table [ mini [ 0 ] ] [ 0 ] +

A[ i ] [ mini [ 0 ] ]
Table [ i ] [ 0 ] = mini [ 0 ]
i f m i n i [0]== b :
r e t u r n Chemin ( Table , a , b )
L=E n l e v e ( L , m i n i [ 0 ] )
-F QSPCMÒNF EV WPZBHFVS EF DPNNFSDF
On présente un autre problème voisin de celui que nous avons traité
dans le paragraphe précédent. Cette fois-ci il s’agit de trouver le plus
court chemin dans le graphe permettant de passer par tous les som-
mets. Pour résoudre ce problème nous allons utiliser un algorithme
de colonie de fourmis.
On note dans la suite n le nombre de sommets du graphe pour lequel

on cherche à résoudre le problème. Comme l’algorithme que l’on
utilisera nécessite de faire des calculs avec les entrées de la matrice
d’adjacence, on ne prendra plus ∞ pour les arêtes n’existant pas mais
un grand nombre (la somme de tous les poids du graphe convient, en
général).
Le principe d’un tel algorithme est d’effectuer plusieurs simulations

de mouvements d’un ensemble de mobiles le long du graphe (les
Rd8
175
fourmis), ces
ces mobiles
mobilesmarquant
marquantààchaque
chaquefois
foisd’une
d’unemanière
manièreououd’une
d’une
autre leur chemin
chemin dans
dans lelegraphe,
graphe,cecequi
quiinfluencera
influenceralelechemin
cheminchoisi
choisi
par les mobiles
mobiles de
de la
la vague
vaguesuivante.
suivante.On
Oncréera
créerapour
pourcela
celaune
unematrice
matrice
carrée de même
même ordre
ordre que
quelalamatrice
matriced’adjacence
d’adjacencedu dugraphe,
graphe,dans
dansla-
la-
quelle on associera
associera àà chaque
chaque arête
arêtedu
dugraphe
grapheun unnouveau
nouveaupoids
poidsque
que
appellera phéromone.
l’on appellera phéromone.
Pour être plus

plus précis,
précis, on
on répétera
répéterales
lesopérations
opérationssuivantes
suivantes: :
• On place N
N fourmis
fourmis au
au hasard
hasardsur
surles
lesnnsommets.
sommets.
• À chaque
chaque fourmi
fourmi on
on associe
associelalaliste
listedes
dessommets
sommetspar
parlesquels
lesquelselle
elle
passe. Initialement
Initialement elle
elle ne
ne contient
contientdonc
doncque
quelelesommet
sommetdededépart
départdede
la fourmi.
• En tenant
tenant compte
compte des
desphéromones,
phéromones,on onfait
faiteffectuer
effectuernn−−11déplace-
déplace-
ments à chaque
chaque fourmi,
fourmi, en
en s’assurant
s’assurantqu’elle
qu’ellenenepasse
passepas
pasdeux
deuxfois
fois
par le même
même sommet
sommet (elle
(elle aadonc
doncparcouru
parcourutout
toutlelegraphe
grapheenenpassant
passant
exactement une
une fois
fois par
par chaque
chaquesommet).
sommet).
• On augmente
augmente lesles phéromones
phéromones sur
surchaque
chaquearête
arêteemprûntée
emprûntéepar
parlala
fourmi, d’une
d’une intensité
intensité d’autant
d’autant plus
plus faible
faible que
queleleparcours
parcoursdedelala
fourmi aura
aura été
été long.
long.
Une fois un certain
certain nombre
nombred’itérations
d’itérationseffectuées,
effectuées,on
ongarde
gardelelemeilleur
meilleur
parcours réussi
réussi par
par les
les fourmis.
fourmis.
Il nous reste
reste àà quantifier
quantifier les
les choses.
choses. On
Onnote
noteAAlalamatrice
matriced’adja-
d’adja-
cence du graphe
graphe et
et B
B lala matrice
matricedes
desphéromones.
phéromones.On Oninitialisera
initialiserales
les
phéromones
phéromones àà 0.01
0.01 sur
sur chaque
chaquearête.
arête.
La probabilité
probabilité qu’une
qu’une fourmi
fourmi située
située en
en lelesommet
sommeti iemprûnte
emprûnteune
une
arête menant
menant au
au sommet
sommet jj sera
seradonnée
donnéeparparl’expression
l’expression: :
bbαi,jαi,jaa−β−β
i,j
i,j
ppi,j
i,j =
=
αα −β −β
kkbbi,k i,kaai,k
i,k
où la somme
somme au au dénominateur
dénominateuraalieulieusur
surles
lesindices
indicesdes
dessommets
sommetsnon
non
encore parcourus
parcourus par
par la
lafourmi.
fourmi.On
Onfixera
fixeralalaprobabilité
probabilitéd’un
d’unsommet
sommet
déjà traversé
traversé àà 0.
0.
Rde
Rde
176
À la fin d’un trajet, on actualisera la matrice B en calculant les nou-
velles valeurs des bi,j données par :
1
bi,j ← r.bi,j +
Lf
f
où la somme a lieu sur l’ensemble des fourmis ayant parcouru l’arête
menant de i à j et où Lf est la longueur du parcours de la fourmi f .
La constante r est un réel positif au choix.
On obtient au final un algorithme dépendant de paramètres plus ou
moins ad hoc, α, β et r. En pratique, α = β = 1 et r = 0, 5 donnent
de bons résultats.
On découpe l’algorithme en plusieurs sous-fonctions :
-hBMHPSJUINF
Fonction P o s i t i o n s I n i t i a l e s ( n , N)
Donnees
n , N, i : e n t i e r s ,
L : l i s t e de l i s t e d ‘ e n t i e r s .
Debut
L <−− [ ]
Pour i v a r i a n t de 0 à N
Faire
L <−− L + [ [ e n t i e r au h a s a r d d a n s [[0, n − 1]] ]
Fin F a i r e
Retourner L
Fin

Spécification : Cette fonction prend en entrée deux entiers : le
nombre de sommets n et le nombre de fourmis de chaque vague N .

Elle retourne la liste des positions initiales des fourmis, sous forme
de liste de listes.
Complexité : Cette fonction est de complexité linéaire en N .
Pour programmer le tirage au sort, on utilise la fonction randint du

module random qui donne un entier tiré au hasard de façon uniforme
entre les deux bornes données en entrée.
Rdd
177
def P o s i t i o n s I n i t i a l e s ( n , N) :
L = []
f o r i i n r a n g e ( 0 ,N) :
L = L + [ [ rd . r a n d i n t (0 , n −1)]]
return L
-hBMHPSJUINF
Fonction L i s t e P r o b a b i l i t é s ( i , LS , A , B , n , a l p h a , b e t a ) :
Donnees
i , j , k , n : entier ,
LS : l i s t e d ’ e n t i e r s ,
A , B : m a t r i c e s de f l o t t a n t s ,
LP : l i s t e de f l o t t a n t s .
alpha , beta : f l o t t a n t s
Debut
LP <−− [ 0 p o u r j v a r i a n t de 0 à n ]
S <−− 0
Faire
S i k n ’ e s t p a s d a n s LS
Alors
S <−− S + B [ i ] [ k ] ∗ ∗ a l p h a

∗ A [ i ] [ k ]∗∗( − b e t a )
Fin S i
Fin F a i r e
Pour j v a r i a n t de 0 à n
Faire
S i j n ‘ e s t p a s d an s LS
Alors
LP [ j ] <−− B [ i ] [ j ] ∗ ∗ a l p h a

∗ A [ i ] [ j ] ∗ ∗ a l p h a /S
Fin S i
Fin F a i r e
Retourner LP
Fin
Rd3
178
Spécification : Cette fonction prend en entrée l’indice i du som-
met sur lequel est la fourmi, la liste Ga des sommets parcourus par la
fourmi en cours, la matrice d’adjacence du graphique et la matrice
" des phéromones, le nombre n de sommets et les constantes alpha
et beta correspondant à α et β. Elle retourne la liste des probabilités
que la fourmi choisisse chaque sommet du graphe comme prochaine
étape.
Complexité : Cette fonction est de complexité linéaire par rap-
port au produit n fois la longueur de Ga.
def L i s t e P r o b a b i l i t e s ( i , LS , A , B , n , a l p h a , b e t a ) :
LP = [ 0 f o r j i n r a n g e ( 0 , n ) ]
S = 0
i f k not i n LS :
S = S+B [ i ] [ k ] ∗ ∗ a l p h a ∗A [ i ] [ k ]∗∗( − b e t a )
i f j not i n LS :
LP [ j ] = B [ i ] [ j ] ∗ ∗ a l p h a ∗A [ i ] [ j ] ∗ ∗ a l p h a
r e t u r n LP
-hBMHPSJUINF
Fonction ChoixSommet ( LP )
Donnees
LP : l i s t e de f l o t t a n t s
S : flottant
i : entier
Debut
a <−− nombre au h a s a r d da n s [ 0 , 1 ]
S <−− LP [ 0 ]
i <−− 0
Tant Que S < a
Faire
i <−− i +1
RdN
179
S <−− S + LP [ i ]
Fin F a i r e
Retourner i
Fin

Spécification : Cette fonction prend en entrée la liste GS des pro-
babilités d’atteindre chacun des sommets. Elle retourne le sommet
choisi.
Terminaison : Comme la somme des éléments de GS est égale à
1, S prendra bien une valeur supérieure ou égale à a.
Correction : l’événement (i = k) est égal à l’événement
i−1
i−1

(a ≤ LP [i]) ∩ (a > LP [i]).
j=0 j=0
Il a donc pour probabilité GS(B).

Complexité : Cette fonction est de complexité linéaire en n.
Pour programmer le tirage au sort, on utilise la fonction rand du
module `M/QK qui donne un entier tiré au hasard de façon uniforme
sur [0, 1].
def ChoixSommet ( LP ) :
a = r d . random ( )
S = LP [ 0 ]
i = 0
while S < a :
i = i +1
S = S+LP [ i ]
return i
R3y
180
-hBMHPSJUINF
Fonction TourComplet (A , B , n , N, a l p h a , b e t a )
Donnees
A , B : m a t r i c e s de f l o t t a n t s
LP : l i s t e de f l o t t a n t s
S : flottant
n, N , i , j , f : entier
alpha , beta : f l o t t a n t s
Debut
L <−− P o s i t i o n s I n i t i a l e s ( n , N)
Faire
Pour f v a r i a n t de 0 à N
Faire
LP <−− L i s t e P r o b a b i l i t é s ( L [ f ] [ − 1 ] ,

L [ f ] , A, B, n , alpha , beta )
j <−− ChoixSommet ( LP )
L [ f ] <−− L [ f ] + [ j ]
Fin F a i r e
Fin F a i r e
Retourner L
Fin
Spécification : Cette fonction prend en entrée la matrice A d’ad-
jacence du graphique et la matrice B des phéromones, le nombre n
de sommets, le nombre N de fourmis et les constantes alpha et beta
correspondant à α et β. Elle retourne la liste des probabilités que la
fourmi choisisse chaque sommet du graphe comme prochaine étape.
Complexité : Cette fonction est de complexité de l’ordre de n3 .N .
def TourComplet (A , B , n , N, a l p h a , b e t a ) :
L = P o s i t i o n s I n i t i a l e s ( n , N)
f o r i i n r a n g e ( 0 , n−1) :
f o r f i n r a n g e ( 0 ,N) :
LP = L i s t e P r o b a b i l i t e s ( L [ f ] [ − 1 ] , L [ f ] ,
R3R
181

A, B, n , alpha , beta )
j = ChoixSommet ( LP )
L[ f ] = L[ f ] + [ j ]
return L
-hBMHPSJUINF
Fonction A c t u a l i s e P h e r o m o n e s ( L , A , B , n , N, r )
Donnees
L : l i s t e de f l o t t a n t s
n, N , i , j , f : entier
r , S : flottants
Debut
Pour i v a r i a n t de 0 à n
Faire
Pour j v a r i a n t de 0 à n
Faire
B [ i ] [ j ] = <−− r ∗ B [ i ] [ j ]
Pour f v a r i a n t de 0 à N
Faire
S <−− 0
Faire
S <−− S + A [ L [ f ] [ i ] ] [ L [ f ] [ i + 1 ] ]
Fin F a i r e
Faire
B [ L [ f ] [ i ] ] [ L [ f ] [ i + 1 ] ] <−−

B[ L [ f ] [ i ] ] [ L [ f ] [ i +1]] + 1
S
Fin F a i r e
Fin F a i r e
Retourner B
Fin

Spécification : Cette fonction prend en entrée la liste des listes
des sommets parcourus par les fourmis, la matrice A d’adjacence du
graphique et la matrice B des phéromones, le nombre n de sommets,
R3k
182
le nombre N de fourmis et la constante r. Elle retourne la matrice
des phéromones mises à jour.
Complexité : Cette fonction est de complexité de l’ordre de n2 .N .
def A c t u a l i s e P h e r o m o n e s ( L , A , B , n , N, r ) :
B [ i ] [ j ] = r ∗B [ i ] [ j ]
f o r f i n r a n g e ( 0 ,N) :
S = 0
f o r i i n r a n g e ( 0 , n−1) :
S = S + A[ L [ f ] [ i ] ] [ L [ f ] [ i +1]]
f o r i i n r a n g e ( 0 , n−1) :
B[ L [ f ] [ i ] ] [ L [ f ] [ i +1]] =

B [ L [ f ] [ i ] ] [ L [ f ] [ i + 1 ] ] + 1/S
return B
On peut enfin donner la fonction déterminant un chemin le plus court :
-hBMHPSJUINF
Fonction C h e m i n L e P l u s C o u r t (A , N, NV, r , a l p h a , b e t a )
Donnees
L , L l : l i s t e de f l o t t a n t s
n, N , i , j , f , NV : e n t i e r
r , a l p h a , b eta , S , l m i n : f l o t t a n t s
Debut
n <−− l e n (A)
B <−− [ [ 0 . 0 1 pour i v a r i a n t de 0 à n ]

pour j v a r i a n t de 0 à n ]
l m i n <−− i n f i n i
Pour i v a r i a n t de 0 à NV
Faire
L <−− TourComplet (A , B , n , N, a l p h a , b e t a )
B <−− A c t u a l i s e P h e r o m o n e s ( L , A , B , n , N, r )
Pour f de 0 à N
R3j
183
Faire
S <−−
<−− 00
Pour ii de
Pour de 00 àà n−1n−1
F a i rree
SS <−−
<−− SS + + AA[[LL[[ ff ]][[ ii ]]]][[ LL[[ ff ]][[ ii+
+11]]]]
Fin F Faaiirree
S i SS < < llm miinn
A l o rrss
llm
miinn <−−
<−− SS
LLll <−−
<−− LL [[ ff ]]
Fin S Sii
Fin F a i r e
Retourner l m miinn ,, LLll
Fin
Analyse de cet algorithme

algorithme ::
Spécification : Cette
Cette fonction
fonction prend
prend enen entrée
entréela matriced’ad-
lamatrice d’ad-
jacence du graphique, le le nombre
nombre N N dede fourmis
fourmis de
de chaque
chaque vague,
vague,lele
nombre Lo de vagues de de fourmis,
fourmis, la
la constante
constanterret etles
lesdeux
deuxconstantes
constantes
HT? et #2i correspondant
correspondant àà α α et
et β.
β. Elle
Elle retourne
retourne lala longueur
longueur du
du
plus court chemin trouvé
trouvé faisant
faisant passer
passer par
par tous
tous les
les sommets
sommets ainsi
ainsi
que la liste ordonnée des
des sommets
sommets par
par lesquels
lesquels passe
passece cechemin.
chemin.
Complexité : La complexité
complexité est
est ici
ici de
de l’ordre
l’ordre de
de N .N..
V.n33.N
NV.n
-F QSPHSBNNF
QSPHSBNNF FO
FO 1ZUIPO
1ZUIPO
def C h e m i n L e P l u ssCCoouurrtt (A
(A,,N, N,NV,
NV, rr ,, aallpphhaa ,, bbeettaa)) ::
n = l e n (A)
B = [ [ 0 . 0 1 ff oorr ii iinn rraannggee ((00 ,,nn))]]

f o r j i n rraannggee ((00 ,,nn ))]]
l m i n = f l o a tt (( ’’ ii nn ff ’’ ))
f o r i i n r a nnggee ((00 ,NV) ,NV) ::
L = TourComplet
TourComplet (A (A,,BB,,nn ,,N,
N, aallpphhaa ,, bbeettaa))
B = A c t uuaalliisseeP Phheerroom moonneess ((LL,,AA,,BB,,nn,,N, N,rr))
f o r f i nn rraannggee ((00 ,N) ,N) ::
S = 00
f o r ii iinn rraannggee ((00 ,,n−1) n−1) ::
SS == SS + +A A[[LL[[ ff ]][[ ii ]]]][[ LL[[ ff ]][[ ii +
+11]]]]
R39
R39
184
i f S < lmin :
lmin = S
L l=L [ f ]
return lmin , L l
5SJ QBS UBT
On termine ce chapitre en présentant un nouvel algorithme de tri. Il

tire parti de la structure de tas, qui est une structure de graphe très
particulière.
On appelle arbre binaire un graphe de la forme suivante :
Chaque sommet à part la racine a a un "père" (situé au-dessus dans
le diagramme) et chaque sommet à part ceux situés en bas du dia-
gramme a deux "fils" (situés au-dessus dans le diagramme).
On appelle tas un arbre binaire dans lequel on associe à chaque som-
met un poids supérieur ou égal à ceux de ses fils. On considère une
liste d’entiers G. Le tri par tas de G se fait en deux étapes. Tout
d’abord on modifie G de façon à ce qu’elle représente un tas, c’est-
à-dire si la construction de l’arbre obtenu en rangeant de bas en haut
et de gauche à droite les éléments de la liste donne un tas. C’est
ainsi le cas avec la liste [10,7,9,4,2,7] qui donne le tas de diagramme
suivant :
R38
185
Dans un deuxième temps, on récupère la liste triée. Pour cela on
sépare notre liste entre une première partie GR correspondant à un tas
et une deuxième Gk donnant la liste triée. On répète alors le processus
suivant :
• On échange le premier élément de GR avec le dernier de GR. La
partie de liste Gk gagne ainsi un élément alors que GR en perd un.
• On fait « descendre » l’élément désormais en première position
dans GR de façon à ce qu’elle corresponde toujours à un tas.
Une fois GR vide, G est triée.
-hBMHPSJUINF
Fonction MiseEnTas ( L )
Donnees
L : liste d‘ entiers
i : entier
Debut
Faire
k<−−i
Tant Que k>0 et L [ ( k −1)//2] < L [ k ]
Faire
L [ ( k − 1 ) / / 2 ] , L [ k ] <−− L [ k ] , L [ ( k −1)//2]
k <−− ( k −1)//2
Fin F a i r e
Fin F a i r e
Retourner L
Fin
R3e
186
Analyse de cet algorithme
algorithme ::
Cette fonction
fonction prend
prend en
en entrée
entrée une
uneliste
listed’entiers
d’entiers
G et retourne une liste contenant
contenant les
les mêmes
mêmes éléments que GG mais
éléments que mais
représentant un tas.
Terminaison : La boucle
boucle Tant
Tant Que
Quetermine
terminecar
carla
lasuite
suitedes
desvaleurs
valeurs
prises par la variable k est
est àà valeurs
valeurs entières
entières et
et strictement
strictement décrois-
décrois-
sante.
Correction : On a l’invariant
l’invariant de
de boucle
boucle :: «« la
la liste
listeformée
forméepar
parles
les
éléments de L d’indices
d’indices inférieurs
inférieurs ou
ou égaux
égaux àà ii représente
représenteun untas
tas».».
Complexité : On notenote nn la
la longueur
longueur dede la listeG.
laliste G.Dans
Danslelepire
piredes
des
cas, on a besoin de l’ordre de HM(i)
l’ordre de HM(i) passages
passages dansdanslalaboucle
boucleTantQue,
TantQue,
on obtient donc une complexité
complexité dansdans lele pire
pire desdes cas
cas de
de l’ordre
l’ordre de
de
n HM(n). Dans le meilleur
meilleur des
des cas,
cas, elle
elle est
est linéaire
linéaire enen n.
n.
-F QSPHSBNNF
QSPHSBNNF FO
FO 1ZUIPO
1ZUIPO
def MiseEnTas ( L )) ::
f o r i i n r a nnggee ((00 ,, lleenn ((LL)))) ::
k = i
while k > > 00 and and LL [[(( kk−1)//2]
−1)//2] < < LL[[kk]] ::
L [ ( kk −
−11))////22]] ,,LL[[ kk ]] = = LL[[kk]] ,, LL[[((kk−1)//2]
−1)//2]
k = (( kk−1)//2
−1)//2
return L
-hBMHPSJUINF
-hBMHPSJUINF
Fonction T r i P a r T Taass ((LL))
Donnees
L : l i s t e d ‘ e n t ii ee rr ss
i , j , n : e n t i e rr
t e s t : booléen
Debut
n <−− l e n ( L ))
L <−− MiseEnTas
MiseEnTas ((LL))
Pour i v a r i aa nn tt de de 00 àà n−1
n−1
Faire
L [ 0 ] , L [ n−1−
n−1−ii ]] <−−<−− LL[[n−1−
n−1−ii ]] ,,LL[[00]]
R3d
R3d
187
j <−− 0
t e s t <−− V r a i
Tant Que t e s t
Faire
S i 2∗ j +1 < n−1− i et

L [ 2 ∗ j +1] >= L [ 2 ∗ j +2] et

L [ 2 ∗ j +1] > L [ j ]
Alors
L [ j ] , L [ 2 ∗ j +1] <−− L [ j ] , L [ 2 ∗ j +1]
j <−− 2∗ j +1
Sinon S i 2∗ j +2 <n−1− i et

L[2∗ j + 2] > L[2∗ j + 1]

et L [ 2 ∗ j +2] > L [ j ]
Alors
L [ j ] , L [ 2 ∗ j +2] <−− L [ j ] , L [ 2 ∗ j +2]
j <−− 2∗ j +2
Sinon
t e s t <−− Faux
Fin S i
Fin F a i r e
Fin F a i r e
Retourner L
Fin

Terminaison : La boucle Tant Que termine car la suite des valeurs
prises par la variable k est à valeurs entières et strictement croissante.
Correction : On a l’invariant de boucle : « la liste formée par les
éléments de G d’indices supérieurs ou égaux à i est triée ».
Complexité : On note n la longueur de la liste G. Dans le pire
des cas, on a besoin de l’ordre de HM(n − i) passages dans la boucle
TantQue, on obtient donc une complexité dans le pire des cas de
l’ordre de n HM(n). Dans le meilleur des cas, elle est linéaire en n.
R33
188
def T r i P a r T a s ( L ) :
n = len (L)
L = MiseEnTas ( L )
f o r i i n r a n g e ( 0 , n−1) :
L [ 0 ] , L [ n−i −1] = L [ n−i −1] , L [ 0 ]
j = 0
t e s t = True
while t e s t :
i f 2∗ j +1 < n−1− i and

L [ 2 ∗ j +1] >= L [ 2 ∗ j +2]

and L [ 2 ∗ j +1]> L [ j ] :
L [ j ] , L [ 2 ∗ j +1] = L [ 2 ∗ j +1] , L [ j ]
j = 2∗ j +1
e l i f 2∗ j +2 < n−1− i and

L [ 2 ∗ j +2] > L [ 2 ∗ j +1] and

L [ 2 ∗ j +2] > L [ j ] :
L [ j ] , L [ 2 ∗ j +2] = L [ 2 ∗ j +2] , L [ j ]
j = 2∗ j +2
else :
test = False
return L
« Si on attend d’une machine d’être infaillible, elle ne peut être
intelligente. »
"MBO 5VSJOH, mathématicien anglais.
R3N
189
"SJUINÏUJRVF
-F DSJCMF Eh&SBUIPTUÒOF
Soit N un entier naturel positif. On cherche à déterminer l’ensemble

constitué de tous les nombres premiers inférieurs ou égaux à N .
-hBMHPSJUINF
Fonction C r i b l e (N)
Donnees
N, n , p , i : e n t i e r s ,
LEntiers , LPremiers : l i s t e s d ‘ e n t i e r s
Debut
L E n t i e r s <−− [ n pour n de 2 a N+1]
L P r e m i e r s <−− [ ]
Tant que L E n t i e r s ! = [ ]
Faire
p <−− L E n t i e r s [ 0 ]
L E n t i e r s <−− L E n t i e r s [ 1 : l e n ( L E n t i e r s ) ]
L P r e m i e r s <−− L P r e m i e r s + [ p ]
n <−− l e n ( L E n t i e r s )
Faire
S i L E n t i e r s [ n−1− i ]%p = 0 A l o r s
L E n t i e r s <−− L E n t i e r s [ 0 : n−1− i ]+

L E n t i e r s [ n−i : l e n ( L E n t i e r s ) ]
Fin S i
Fin F a i r e
Retourner L P r e m i e r s
Fin
RNy
190
non nul N et retourne la liste des nombres premiers inférieurs ou
égaux à N .
Terminaison : À chaque passage dans la boucle, la liste G1MiB2`b
perd au moins son premier élément. Elle sera donc vide en au pire
N − 1 passages dans la boucle.
Correction : On a pour invariant de boucle : « Les éléments de
la liste G1MiB2`b ne sont pas divisibles par les entiers inférieurs stric-
tement au premier élément de la liste G1MiB2`b ». En particulier, ce
premier élément est bien un nombre premier.
Complexité : On peut majorer le nombre de passages dans la
boucle Tant Que par N . Pour chaque passage dans cette boucle, on
effectue une boucle Pour parcourant les éléments de G1MiB2`b ef-
fectuant une comparaison et un nombre d’affectations borné par la
longueur de G1MiB2`b. On obtient donc une complexité quadratique
en N .
def C r i b l e (N) :
L E n t i e r s =[n f o r n i n r a n g e ( 2 ,N+1)]
LPremiers =[]
while L E n t i e r s !=[] :
p=L E n t i e r s [ 0 ]
L E n t i e r s=L E n t i e r s [ 1 : l e n ( L E n t i e r s ) ]
L P r e m i e r s +=[p ]
n=l e n ( L E n t i e r s )
i f L E n t i e r s [ n−1− i ]%p==0 :
L E n t i e r s=L E n t i e r s [ 0 : n−1− i ]+

L E n t i e r s [ n−i : l e n ( L E n t i e r s ) ]
return LPremiers
RNR
191
$BMDVM EF MB GPODUJPO ϕ EF &VMFS
-hBMHPSJUINF
Fonction P h i (N)
Donnees
N, P o s i t i o n , n , l , i : entier ,
LEntiers : l i s t e d ‘ entiers
Debut
L E n t i e r s <−− [ n pour n de 2 a N−1]
P o s i t i o n <−− 0
Tant que P o s i t i o n <l e n ( L E n t i e r s )
Faire
n <−− L E n t i e r s [ P o s i t i o n ]
S i N%n=0 A l o r s
Faire
l <−− l e n ( L E n t i e r s )
Pour i de 0 a l −P o s i t i o n
Faire
S i L E n t i e r s [ l −1− i ]%n=0 A l o r s
Faire
L E n t i e r s <−− L E n t i e r s [ 0 : l −1− i ]+

L E n t i e r s [ l −i : l e n ( L E n t i e r s ) ]
Fin F a i r e
Fin S i
Fin F a i r e
Fin F a i r e
Sinon
P o s i t i o n <−− P o s i t i o n +1
Fin S i
Fin F a i r e
Retourner l e n ( L E n t i e r s )+1
Fin

non nul N et retourne le nombre d’entiers naturels inférieurs à N et
premiers avec N .
RNk
192
Terminaison : À chaque passage dans la boucle Tant Que, la liste
G1MiB2`b perd au moins un élément ou SQbBiBQM augmente de 1. Par
conséquent, la suite des valeurs prises par la longueur de G1MiB2`b
moins SQbBiBQM est à valeurs entières et strictement décroissante. Elle
prendra donc bien la valeur 0.
Correction : On a pour invariant de boucle : « Les éléments de la
liste G1MiB2`b d’indice inférieur à Position sont premiers avec N ».
Complexité : Dans le pire des cas, le nombre de passages dans
la boucle Tant Que sera égal à N − 2. Au i-ième passage dans cette

boucle, la boucle Pour de l’ordre de la longueur de G1MiB2`b moins
SQbBiBQM OPEL. On peut donc majorer ce nombre d’OPEL par N-i
ce qui en sommant pour i allant de 1 à N − 2 donne une complexité
globale quadratique en N .
def P h i (N) :
L E n t i e r s =[n f o r n i n r a n g e ( 2 ,N ) ]
P o s i t i o n =0
w h i l e P o s i t i o n <l e n ( L E n t i e r s ) :
n=L E n t i e r s [ P o s i t i o n ]
i f N%n==0 :
l=l e n ( L E n t i e r s )
f o r i i n r a n g e ( 0 , l −P o s i t i o n ) :
i f L E n t i e r s [ l −1− i ]%n==0 :
L E n t i e r s=L E n t i e r s [ 0 : l −1− i ]+

L E n t i e r s [ l −i : l e n ( L E n t i e r s ) ]
else :
P o s i t i o n=P o s i t i o n +1
r e t u r n l e n ( L E n t i e r s )+1
RNj
193
"MHPSJUINF Eh&VDMJEF ÏUFOEV
-hBMHPSJUINF
Fonction E u c l i d e E t e n d u ( a , b )
Donnees
a ,b : entiers ,
r0 , u0 , v0 , r1 , u1 , v1q , r : e n t i e r s
uIntermediaire , vIntermediare : entiers
Debut
r0 , u0 , v0 <−− a , 1 , 0
r1 , u1 , v1 <−− b , 0 , 1
Tant que r 1 �= 0
Faire
q , r <−− r 0 // r1 , r 0%r 1
u I n t e r m e d i a i r e <−− u0−q∗ u1
v I n t e r m e d i a i r e <−− v0−q∗ v1
r0 , u0 , v0 <−− r1 , u1 , v1
r1 , u1 , v1 <−− r , u I n t e r m e d i a i r e , v I n t e r m e d i a i r e
Fin F a i r e
Retourner ( r0 , u0 , v0 )
Fin

Spécification : Cette fonction prend en entrée deux entiers natu-
rels a et b et retourne des entiers naturels r0, u0 et v0 tels que r0 soit
le pgcd de a et de b et tels que l’on ait r0 = u0.a + v0.b.
Terminaison : La suite des valeurs prises par la variable r0 est
à valeurs entières et strictement décroissante à partir du deuxième
terme. La variable r0 prendra donc bien la valeur 0.
Correction : Un invariant de boucle est la propriété
« `y 4 myX Y pyX# 2i `R 4 mRX Y pRX# ».
Complexité : On peut prouver par récurrence que le pire des cas
est celui où a et b sont deux termes consécutifs de la suite de Fibo-

nacci. Si on note le nième terme de la suite de Fibonacci Fn alors le
nombre d’itération de la boucle est n − 1 si a = Fn et b = Fn−1 .
RN9
194
Or Fn est de l’ordre de en , on a donc une complexité globale de
l’algorithme logarithmique en Kt(a, b).
def E u c l i d e E t e n d u ( a , b ) :
r0 , u0 , v0=a , 1 , 0
r1 , u1 , v1=b , 0 , 1
w h i l e r 1 !=0 :
q , r=r 0 // r1 , r 0%r 1
u I n t e r m e d i a i r e=u0−q∗ u1
v I n t e r m e d i a i r e=v0−q∗ v1
r0 , u0 , v0=r1 , u1 , v1
r1 , u1 , v1=r , u I n t e r m e d i a i r e , v I n t e r m e d i a i r e
r e t u r n r0 , u0 , v0
$IJGGSFNFOU 34"
On va écrire ici une fonction permettant de chiffrer et de déchif-

frer en utilisant l’algorithme RSA. On rappelle qu’étant donné deux
nombres premiers p et q distincts, on obtient la clé publique du chif-
frement (n, e) en prenant n = pq et e premier avec ϕ(n). La clé
privée est alors d tel que de soit congru à 1 modulo ϕ(n). On va de
plus écrire une fonction calculant d étant donné p et q. La sécurité du
chiffrement repose en effet sur la difficulté de retrouver p et q étant
donné n si ceux-ci sont suffisamment grands.
On donne enfin une fonction permettant de chiffrer un texte. On
utilise la fonction ord de P YTHON donnant un entier associé à un
caractère. On récupère le caractère avec chr.
-hBMHPSJUINF
Fonction C h i f f r e m e n t ( a , b )
Donnees
a ,b : entiers ,
r0 , u0 , v0 , r1 , u1 , v1q , r : e n t i e r s
uIntermediaire , vIntermediaire : entiers
RN8
195
Debut
r0 , u0 , v0 <−− a , 1 , 0
r1 , u1 , v1 <−− b , 0 , 1
Tant que r 1 �= 0
Faire
q , r <−− r 0 // r1 , r 0%r 1
u I n t e r m e d i a i r e <−− u0−q∗ u1
v I n t e r m e d i a i r e <−− v0−q∗ v1
r0 , u0 , v0 <−− r1 , u1 , v1
r1 , u1 , v1 <−− r , u I n t e r m e d i a i r e , v I n t e r m e d i a i r e
Fin F a i r e
Retourner ( r0 , u0 , v0 )
Fin
def C a l c u l C l e ( p , q , e ) :
r , u , v=E u c l i d e E t e n d u ( ( p −1)∗( q −1) , e )
i f v<0 :
v=v+(p −1)∗( q−1)
return v
def C h i f f r e m e n t ( n , e , a ) :
r e t u r n a ∗∗ e%n
def C h i f f r e m e n t T e x t e ( n , e , T) :
NT= ’ ’
for c in T :
NT=NT+c h r ( C h i f f r e m e n t ( n , e , o r d ( c ) ) )
r e t u r n NT
Pour décoder, il suffit d’utiliser les mêmes fonctions que celles utili-
sées dans le codage mais avec la clé d à la place de e.
RNe
196
"VUPVS EFT QPMZOÙNFT
3FQSÏTFOUBUJPO FU NBOJQVMBUJPO EF QPMZOÙNFT
Les polynômes n’ont pas de représentation naturelle en P YTHON. On

représente ici un polynôme
d

P (x) = ai X i
i=0
par le tableau de ses coefficients sous forme de flottants, [a0 , . . . , ad ]

avec ad non nul ou d = 0. Ainsi, le polynôme X + 2X 3 pourra être
représenté par le tableau [0.,1.,0.,2.].
De façon à pouvoir programmer l’algorithme d’Euclide étendu pour
de tels polynômes, nous commençons par définir quelques fonctions
permettant d’effectuer les opérations algébriques de base. Nous nous
contentons ici de donner les fonctions P YTHON. On peut juste pré-
ciser que la fonction L2iiQB2 sert à éliminer les premiers termes de
la liste représentant un polynôme si ceux-ci sont nuls ou quasi-nuls.
De tels termes pourront en effet apparaître suite aux calculs effectués
dans la division euclidienne.
def N e t t o i e (P) :
w h i l e ( a b s (P[ −1]) >10∗∗ −15 and l e n (P) >1) :
P=P [ 0 : l e n (P) −1]
return P
def Degre (P) :
i f l e n (P)>1 :
r e t u r n l e n (P)−1
e l i f a b s (P[0]) >10∗∗ −15 :
return 0
else :
r e t u r n −np . I n f
RNd
197
def Somme( P1 , P2 ) :
P= [ ]
m=min ( l e n ( P1 ) , l e n ( P2 ) )
M=max ( l e n ( P1 ) , l e n ( P2 ) )
f o r i i n r a n g e ( 0 ,m) :
P=P+[P1 [ i ]+P2 [ i ] ]
P=P+P1 [m :M]
P=P+P2 [m :M]
return P
def P r o d u i t ( P1 , P2 ) :
P=[0 f o r i i n r a n g e ( 0 , l e n ( P1)+ l e n ( P2 ) −1)]
f o r i i n r a n g e ( 0 , l e n ( P1 ) ) :
f o r j i n r a n g e ( 0 , l e n ( P2 ) ) :
P [ i+j ]=P [ i+j ]+P1 [ i ] ∗ P2 [ j ]
return P
%JWJTJPO FVDMJEJFOOF
-hBMHPSJUINF
Fonction D i v i s i o n E u c l i d i e n n e ( P1 , P2 )
Donnees
P1 , P2 : p o l y n ô m e s
R , Q, P i n t : p o l y n ô m e s
Coeff : f l o t t a n t
Debut
R<−−P1
Q<−−0
Tant que deg (R)>=deg ( P2 )
Faire
C o e f f <−− C o e f f D o m i n a n t (R) / C o e f f D o m i n a n t ( P2 )
P i n t <−−− C o e f f ∗X^( deg (R) − deg ( P2 ) )
R <−− R+P2∗ P i n t
Q <−− Q+C o e f f ∗X^( deg (R) − deg ( P2 ) )
Fin F a i r e
Retourner (Q, R)
Fin
RN3
198
Analyse de c
Analyse
Analyse
Analyse
dede
decet
cet
cetalgorithme
algorithme
algorithme:: : Spécificati
Spécification: :Cette
Spécification
Cettefonction
fonction
fonctionprend
prenden en
enentrée
entrée
entréedeux
deux
deuxpolynômes
polynômes
polynômes P1 et P2 et ret
P1P1et et
P2P2
P2
et et
et
retourne
retourne
retournelelelequotient
quotient
quotientQ
QQetetlelereste
reste
resteRRRde
de
delalaladivision
division
divisiondedeP1P1
par P2.
parpar
P2.P2.
P2. Terminaiso
Terminaison: :La
Terminaison
Terminaison : La
Lasuite
suite
suitedes
des
desdegrés
degrés
degrésdes
des
despolynômes
polynômes
polynômesstockés
stockés
stockésdans
dansla variable R e
la la
variable
variable
variable
R RR
estest
està àvaleurs
à valeurs
valeursentières
entières
entièresetetstrictement
strictement
strictementdécroissante.
décroissante.
décroissante.Elle
Elle
prendra donc l
prendra
prendra
prendradonc
donc
donclala
la
valeur
valeur
valeur0.0.0. Correction
Correction: :On
Correction
Correction : On
Onaapour
apour
pourinvariant
invariant
invariantdedeboucle
boucle
boucle::«:««PPP
111==
=Q.P
Q.P
Q.P 2 2++RR». Comme le d
». ».
Comme
Comme
Comme lele
le
dernier
dernier
dernierRRRest
est
estde
de
dedegré
degré
degréstrictement
strictement
strictementinférieur
inférieur
inférieurà àcelui
à celui
celui
dede
P2, il s’agit bi
P2,P2,
il s’agit
il s’agit
s’agit
bien
bien
biendudu
dureste
reste
restede
de
delalaladivision
division
divisioneuclidienne,
euclidienne,
euclidienne,etetetQQ
Qestest
estdonc
donc
bien le quotien
bien
bien
le le
quotient.
quotient.
quotient. Complexité
Complexité: :À
Complexité
Complexité : ÀÀ
chaque
chaque
chaquepassage
passage
passagedans
dansla
lalaboucle
boucle
boucleTant
Tant
TantQue,
Que,
Que,
lele
le
degré
degré
de R diminue
de de
R Rdiminue
diminue
diminuedudududegré
degré
degréde de
deP2.
P2.
P2.OnOn
Onobtient
obtient
obtientdonc
donc
doncun
un
unnombre
nombre
nombretotal
total
d’opérations li
d’opérations
d’opérations
d’opérations
linéaire
linéaire
linéaireen
en
endeg(P
deg(P 1)1)−
deg(P1) −−deg(P
deg(P
deg(P2).2).
2).
def D i v i s i o
f D iD
d edef Dvii vvsiissoiinoonEnEuEucuclcil ldi ididieienennnneee((P1 (P1P1, P2 , P2) ):: : P1 , P2=N
P1P1
P1 , P2=N
,, P2=N
P2=N e teetttottoioei ie(e(P1 (P1P1 )),), N,NNeetet t ot oi ei e( P2(P2
P2))) R=P1 [ :]
R=P1
R=P1
R=P1 [ :[[]::]] Q= [ 0 . 0
Q= Q=
Q= [ 0[[.00..00f offororr i i i i n i inn rraranann gggeee(( 0( 0, ,l el ennn((P1)−
(P1)−
P1)− l lelenenn( (P2
(P2P2 )+ ))+
+1 )11]) ] w h i l e D
w hwwihh l eiilleeDegre
Degre
Degre (R)>=Degre
(R)>=Degre
(R)>=Degre(( P2 ( P2) ): : C o
Co CCeoofeef=R[
fff=R[
f=R[ −1]/
−1]/
−1]/ P2P2P2 [[−1]
[−1]
−1] Pin
P iPPniitnn=[0tt=[0
=[0f fofororr i i i iinni n rr ar anng ge e((0(00,, l,lelenenn(R)− (R)−
(R)− l ellenen(nP2
((P2
P2 ) ))]) ] P in
P iPPniit=P
nnt=Pt=P i ni intnt+[−1∗
t+[−1∗
+[−1∗CCCoooee ef ff f] ] R=S
R=Somme(R
R=Somme(R
R=Somme(R , ,P,PP rrorododduuuiitti t(( P2
( P2, ,PPPiinni ntt t)))))) Q[ l
Q[Q[ Q[l ellneen(R)−
n(R)−
(R)− l el lenenn((P2
(P2P2 )]=
)]=
)]=CCooe effff f R=N
R=N R=N
R=N e teetttottoioei ie(R)
e(R) (R) r e t u rn
r errteeuttruunrrnnQ,Q, Q,RRR
-hBMHPSJUIN
-hBMHPSJUINF
-hBMHPSJUINF
-hBMHPSJUINFQPVS
QPVS
QPVSMFT
MFT
MFTQPMZOÙNFT
QPMZOÙNFT
QPMZOÙNFT
Il ne reste plu
Il ne
Il ne
reste
reste
reste
plus
plus
plusqu’à
qu’à
qu’àtranscrire
transcrire
transcrirel’algorithme
l’algorithme
l’algorithmeutilisé
utilisé
utilisépour
pour
pourles les
lesentiers
entiers relatifs avec ce
relatifs
relatifs
relatifs
avec
avec
aveccesces
ces
nouveaux
nouveaux
nouveauxoutils.
outils.
outils.Pour
Pour
Pourlaladescription
description
descriptiondede
del’algorithme,
l’algorithme,
l’algorithme, on garde les n
onongarde
garde
gardelesles
les
notations
notations
notationsdes
des
desopérations
opérations
opérationsutilisées
utilisées
utiliséesen
en
enPPYTHON
PYTHON
YTHON avec
avec
aveclesles
entiers.
entiers.
entiers.
entiers.
RNN
RNN
RNN
199
-hBMHPSJUINF
Fonction E u c l i d e E t e n d u ( P1 , P2 )
Donnees
P1 , P2 : polynômes ,
R0 , U0 , V0 , R1 , U1 , V1 , Q, R : p o l y n ô m e s
U I n t e r m e d i a i r e , V I n t e r m e d i a r e : polynômes
Debut
R0 , U0 , V0 <−− P1 , 1 , 0
R1 , U1 , V1 <−− P2 , 0 , 1
Tant que d e g r é ( R1 ) > 0
Faire
Q, R <−− R0//R1 , R0%R1
U I n t e r m e d i a i r e <−− U0−Q∗U1
V I n t e r m e d i a i r e <−− V0−Q∗V1
R0 , U0 , V0 <−− R1 , U1 , V1
R1 , U1 , V1 <−− R , U I n t e r m e d i a i r e , V I n t e r m e d i a i r e
Fin F a i r e
Retourner ( R0 , U0 , V0 )
Fin

Spécification : Cette fonction prend en entrée deux polynômes
P 1 et P 2 et retourne trois listes polynômes R0, U 0 et V 0 tels que
R0 est le pgcd des polynômes P 1 et P 2 et U 0.P 1 + V 0.P 2 = R0.
Terminaison : La suite des degrés des polynômes stockés dans
R1 est une suite d’entiers strictement décroissante à partir du rang 1,
elle prendra donc bien une valeur négative ou nulle.
Correction : On a pour invariant de boucle : « R0 = U 0.P 1 +
V 0.P 2 et R1 = U 1.P 1 + V 1.P 2 ». Comme le dernier R0 est le
dernier reste de degré strictement positif, il contient bien le pgcd des
polynômes considérés.
Complexité : Le nombre de passages en boucle est de l’ordre du
maximum des degrés de P 1 et P 2. Pour déterminer la complexité
de l’algorithme, il faut ensuite estimer les degrés des polynômes
successifs auxquels on applique la division euclidienne. Finalement,
on peut montrer que l’algorithme est linéaire en deg(P 1).deg(P 2).
kyy
200
-F
-F QSPHSBNNF
QSPHSBNNFFO
FO1ZUIPO
1ZUIPO
d e f E uucclliiddeeEEtteenndduu((P1
def P1, ,P2 P2)): :
R0
R0 ,, U0
U0,,V0=P1
V0=P1,,[[11..00] ] , ,[ [00. .00] ]
R1
R1 ,, U1
U1,,V1=P2
V1=P2,,[[00..00] ] , ,[ [11. .00] ]
whhiillee lleenn ((R1)>1
w R1)>1: :
Q,
Q,R=D
R=Diivviissi ioonnEEuuccl li iddi ei ennnnee( (R0
R0, R1, R1) )
U
UIInntteerrm meeddi iaai irre=N
e=Neet tt tooi ei e( (

Somme(
Somme(U0 U0,,PPrroodduui ti t((PPr roodduui ti t( [( [−−1 1. 0. 0] ,Q)
] ,Q), U1 , U1 ) )))) )
V
VIInntteerrm meeddi iaai irre=N
e=Neet tt tooi ei e( (

Somme(
Somme(V0 V0,,PPrroodduui ti t((PPr roodduui ti t( [( [−−1 1. 0. 0] ,Q)
] ,Q), V1 , V1 ) )))) )
R0
R0,,U0U0,,V0=R1
V0=R1, ,U1 U1, ,V1
V1
R1
R1,,U1U1,,V1=R
V1=R,,UUI Inntteer rmmeeddi ai ai ri re e, ,VVI nI nt et er m
r me de d
i ai iarier e
r eettuurrnn R0R0,,U0U0,,V0V0
#PÔUF
#PÔUF ËËPVUJMT
PVUJMT
module MmKTvXTQHvMQKBH
Le module MmKTvXTQHvMQKBHfournit
fournitune
uneclasse
classededepolynômes
polynômesappelée
appelée
SQHvMQKBH.
SQHvMQKBH. Après
Après avoir
avoirimportée
importéecelle-ci,
celle-ci,on
ondispose
disposedesdesfonctions
fonctions
et méthodes
méthodes suivantes
suivantes::
retourne
retourne lelepolynôme
polynômedont
dontlesles
SQHvMQKBHUGV
SQHvMQKBHUGV
coefficients
coefficientssont
sontdans
dansLL
applique
appliquelelepolynôme
polynômePPà àununouou
SUV
des
deséléments
éléments
donne
donne lele coefficient
coefficientdededegré
degré
SX+Q27()
SX+Q27()
précisé
précisé
SX/2;`22UV
SX/2;`22UV donne
donneleledegré
degrédedePP
SX`QQibUV
SX`QQibUV donne
donneles
lesracines
racinesdedePP
SX/2`BpUV
SX/2`BpUV donne
donnelelepolynôme
polynômedérivé
dérivédedeP P
S ff ZZ donne
donnelelequotient
quotientdedePPpar
parQQ
donne
donnelelereste
restededelaladivision
divisiondede
S W ZZ
PPpar
parQQ
kyR
kyR
201
(BVTT-FHFOESF
1PMZOÙNFT EF -FHFOESF
Pour tout entier naturel k on appelle k-ième polynôme de Legendre

le polynôme :
1 dk
Pk (X) = ((X 2 − 1)k )
2k k! dxk
Ces polynômes forment une suite de polynômes orthogonaux pour

le produit scalaire défini sur l’ensemble des fonctions continues sur
[−1, 1] par :
1
< f, g >= fg
−1
La suite (Pk ) des polynômes de Legendre vérifie pour tout k 2 :
2k − 1 k−1
Pk (X) = XPk−1 (X) − Pk−2 (X)
k k
Cette relation de récurrence, nous fournit une méthode efficace pour

calculer les polynômes de Legendre ainsi que leurs polynômes déri-
vés en P YTHON.
Nous ne détaillons pas l’algorithme pour les polynômes dérivés, qui
est le même mais en appliquant la relation de récurrence vérifiée par
la suite (Qk ) des polynômes dérivés des polynômes de Legendre :
2k−1 2k−1 k−1

Qk (X) = Pk−1 (X) + Qk−1 (X) − Qk−2 (X)
k k k
kyk
202
-hBMHPSJUINF
Fonction C a l c u l P o l y n o m e L e g e n d r e ( n )
Donnees
n : entiers ,
P1 , P2 ,Q : polynômes ,
k : entier
Debut
P1 <−− [ 1 . 0 ]
P2 <−− [ 0 . , 1 . ]
S i k = 0 a l o r s Retourner P1 F i n S i
Faire
Q <−− P2
P2 <−− ( 2 ∗ k −1)/ k ∗X∗P1 − ( k −1)/ k ∗P2
P1 <−− Q
Fin F a i r e
Retourner P2
Fin
def C a l c u l P o l y n o m e L e g e n d r e ( n ) :
P1 = [ 1 . ]
P2 = [ 0 . , 1 . ]
i f k==0 :
r e t u r n P1
f o r k i n r a n g e ( 2 , n+1) :
Q=P2 [ : ]
P2=Somme( P r o d u i t ( [ 0 . , ( 2 ∗ k −1)/ k ] , P1 ) ,

P r o d u i t ([ −( k −1)/ k ] , P2 ) )
P1=Q [ : ]
r e t u r n P2
def C a l c u l P o l y n o m e L e g e n d r e D ( n ) :
P1 = [ 0 . ]
P2 = [ 1 . ]
i f k==0 :
r e t u r n P1
f o r k i n r a n g e ( 2 , n+1) :
kyj
203
Q=P2 [ : ]
P2=Somme( C a l c u l P o l y n o m e L e g e n d r e ( k −2) ,

Somme( P r o d u i t ( [ 0 . , ( 2 ∗ k −1)/ k ] , P1 ) ,

P r o d u i t ([ −( k −1)/ k ] , P2 ) ) )
P1=Q [ : ]
r e t u r n P2
.ÏUIPEF EhJOUÏHSBUJPO OVNÏSJRVF
Comme on ne présente pas à proprement parler de nouvel algorithme

ici, mais plutôt des applications des algorithmes classiques dejà pré-
sentés auparavant, on se contentera ici de donner les programmes en
P YTHON.
Le principe de la méthode
1 d’intégration de Gauss-Legendre est d’ap-
procher une intégrale −1 f (x)/x par une somme de la forme
n
wk f (xk )
k=1
où les xk sont les racines de Pk et où les wk sont les réels tels que
pour tout polynôme Q de degré inférieur ou égal à 2n − 1 on ait :
1 n
Q(t)/x = wk Q(xk ).
−1 k=1
Pour déterminer les racines xk , on peut utiliser la méthode
de Newton.
On prend comme comme valeur initiale +Qb n+0,5 π pour appro-
k−0,25
cher xk . On obtient la fonction suivante :
def RacApprochee ( k , i , e p s i l o n ) :
u0=np . c o s ( np . p i ∗ ( i − 0 . 2 5 ) / ( k + 0 . 5 ) )
L=C a l c P p r i m e ( u0 , k )
u1=u0−L [ 0 ] / f l o a t ( L [ 1 ] )
w h i l e a b s ( u1−u0)> e p s i l o n :
L=C a l c P p r i m e ( u1 , k )
u0 , u1=u1 , u1−L [ 0 ] / f l o a t ( L [ 1 ] )
r e t u r n u1
ky9
204
Les wk peuvent eux être déterminés en résolvant le système formé
par les équations :
1 n

xp /x = wk xpk
−1 k=1
pour p allant de 0 à n. Ce système est bien de Cramer car il est

défini par une matrice de Van Der Monde. En réutilisant la fonction
aQHmiBQMn:mbb (voir p 129), on obtient :
def C a l c C o e f f ( n ) :
a=−1
b=1
L=[ RacApprochee ( n , i , 0 . 0 1 )

f o r i i n r a n g e ( 1 , n +1)]
LY=[( a+b )/2.0+ x ∗ ( b−a ) / 2 . 0 f o r x i n L ]
M=np . a r r a y ( [ [ y ∗∗ k f o r y i n LY ]

for k in range (0 , n ) ] )
B=np . a r r a y ( [ ( b ∗∗ k−a ∗∗ k ) / f l o a t ( k )

for k in range (1 , n +1)])
X=S o l u t i o n _ G a u s s (M, B)
r e t u r n [ [ x [ 0 ] f o r x i n X ] , LY ]
En utilisant finalement un changement de variable, on peut écrire une
fonction
b permettant de calculer une valeur approchée d’une intégrale
a f (t)/t par la méthode détaillée ci-dessus :
def C a l c L e g e n d r e ( f , a , b , n , N) :
L=C a l c C o e f f ( n )
S=0
f o r i i n r a n g e ( 0 ,N) :
print S , L
g=lambda x :

f ( a+(b−a ) ∗ ( 2 ∗ i +1)/ f l o a t ( 2 . 0 ∗N)+

x ∗ ( b−a ) / ( 2 . 0 ∗N) )
Stemp=sum ( [ f l o a t ( L [ 0 ] [ k ] ) ∗ g ( L [ 1 ] [ k ] )

for k in range (0 , len (L [ 0 ] ) ) ] )
S=S+(b−a ) / ( 2 . 0 ∗N) ∗ Stemp
return S
ky8
205
#PÔUF Ë PVUJMT
Le module MmKTvXb+BTvXH2;2M/`2 contient la fonction suivante :
retourne deux tableaux donnant

les points et les poids à utiliser
H2;;mbbU/V
dans la méthode pour un résultat
exact jusqu’au degré 2d + 1
« Si les gens ne croient pas que les mathématiques sont simples,

c’est uniquement parce qu’ils ne réalisent pas à quel point la
vie est compliquée. »
+PIO 7PO /FVNBOO, mathématicien américain.
kye
206
1SPCBCJMJUÏT
4JNVMBUJPO EFT MPJT DMBTTJRVFT
On utilisera ici la fonction `M/QK du module du même nom don-

nant comme résultat un nombre « aléatoire » de l’intervalle [0, 1[.
Les seules propriétés à connaître sur ce nombre sont d’une part que
la probabilité d’obtenir un élément d’un intervalle de bornes α et β
avec 0 α β 1 est β − α et d’autre part que les appels à cette
fonction sont indépendants les uns des autres.
On donne dans ce paragraphe des programmes simulant les lois uni-
forme, binomiale et géométrique.
-hBMHPSJUINF
Fonction S i m u l a t i o n U n i f o r m e ( a , b )
Donnees
a ,b : entiers
Debut
t <−− random ( )
t <−− t ∗ ( b−a+1)+a
t <−− P a r t i e E n t i e r e ( t )
Retourner t
Fin

Spécification : Cette fonction prend en entrée deux entiers natu-
rels a et b tels que l’on ait a < b et retourne un entier de l’ensemble
{a, . . . , b} avec la même probabilité pour chaque résultat possible.
Correction : la probabilité que l’on obtienne comme résultat k
que le nombre obtenu avec `M/QK appartienne à
est la probabilité
k−a k+1−a 1
b−a+1 , b−a+1 . Cette probabilité est donc bien égale à b−a+1 .
kyd
207
def S i m u l a t i o n U n i f o r m e ( a , b ) :
t=r d . random ( )
t=t ∗ ( b−a+1)+a
t=i n t ( t )
return ( t )
-hBMHPSJUINF
Fonction S i m u l a t i o n B i n o m i a l e ( n , p )
Donnees
n : entier
p : flottant
Debut
S=0
Pour i v a r i a n t de 1 à n+1
t <−− random ( )
Si t < p
A l o r s S <−− S+1
Fin S i
Retourner S
Fin

n et un flottant p appartenant à [0, 1]. Elle retourne un entier naturel
inférieur ou égal à n tel que la probabilité de chaque résultat possible
suive la loi binomiale de paramètres n et p.
Correction : À chaque passage dans la boucle Pour, la probabi-
lité que l’on ajoute 1 à la variable S est égale à p car c’est la probabi-
lité que `M/QKUV donne un nombre de l’intervalle [0, p]. À la sortie
de la boucle, S contient donc la somme de n variables aléatoires pre-
nant la valeur 1 avec la probabilité p et la valeur 0 avec la probabilité
1 − p. Comme la somme de n variables aléatoires indépendantes de
même loi de Bernoulli de paramètre p suit la loi binomiale de para-
mètres n et p, le résultat de la fonction suit bien la loi attendue.
ky3
208
Complexité : Lors de l’exécution de cet algorithme, on effectue
3n OPEL et n appels à la fonction `M/QKUV.
def S i m u l a t i o n B i n o m i a l e ( n , p ) :
S=0
f o r i i n r a n g e ( n+1) :
t=r d . random ( )
if t < p :
S=S+1
return (S)
-hBMHPSJUINF
Fonction S i m u l a t i o n G e o m e t r i q u e ( p )
Donnees
p : flottant
Debut
N <−− 0
Tant Que random ( ) >p
Faire
N <−− N+1
Fin F a i r e
Retourner N
Fin

Spécification : Cette fonction prend en entrée un flottant p élé-
ment de [0, 1]. Elle retourne un entier naturel non nul tel que la pro-
babilité de chaque résultat possible suive la loi géométrique de para-
mètre p.
∗
Correction : Soit k ∈ N . la probabilité que la variable N soit
égale à k à la fin de la boucle Tant Que est la probabilité que l’on

ait obtenu k − 1 fois un résultat de `M/QK appartenant à [p, 1] puis
un résultat appartenant à [0, p]. Par indépendance, la probabilité de
retourner k est donc égale à (1 − p)k−1 × p, ce qui donne bien un
résultat suivant la loi géométrique de paramètre p.
kyN
209
Complexité : Lors de l’exécution de cet algorithme, si on fait n
passages dans la boucle on effectue 3n − 2 OPEL et n appels à la
fonction `M/QKUV.
def S i m u l a t i o n G e o m e t r i q u e ( p ) :
N=0
w h i l e r d . random ( ) >= p :
N=N+1
r e t u r n (N)
$PNQBSBJTPO EFT MPJT CJOPNJBMF FU EF 1PJTTPO
Pour comparer le comportement de variables aléatoires suivant des

lois de la forme P(λ) et B(n, λ/n) on va simuler un nombre N de
tirages suivant la loi binomiale pour un n et calculer la proportion
obtenue pour chaque valeur. On tracera alors la fonction de réparti-
tion théorique correspondant à la loi de Poisson ainsi que la fonction
de répartition empirique obtenue pour la loi binomiale pour compa-
rer. On utilisera pour ce faire une fonction aQKK2*mKmH22 calculant
les sommes partielles correspondant à une liste donnée.
-hBMHPSJUINF
Fonction C o m p a r a i s o n B i n o m i a l e P o i s s o n ( λ , n , N)
Donnees
n , N, i , a : e n t i e r s
λ : flottant
LB , LP : l i s t e s de f l o t t a n t s
Debut
LB <−− [ 0 pour i v a r i a n t de 0 à n+1]
Pour i v a r i a n t de 0 à N
Faire
a <−− S i m u l a t i o n B i n o m i a l e ( n , l /n )
LB [ a ] <−− LY [ a ] + 1/N
Fin F a i r e
kRy
210
p l o t ( SommeCumulee ( LY ) , ’ r ’ )
LP <−− [ exp (−λ ) ]
Faire
LP <−− LP + [ LP [ − 1 ] / ( i +1)∗λ ]
Fin F a i r e
T r a c e r ( SommeCumulee ( LP ) , ’ b ’ )
Fin

Spécification : Cette fonction prend en entrée un flottant λ et
deux entiers n et N . Elle trace la fonction de répartition empirique
pour la loi binomiale de paramètres n et p (en rouge) et la fonction de
répartition théorique pour la loi de Poisson de paramètre λ (en bleu).
Correction : La première boucle Pour simule N tirages de la loi
binomiale et en sortie de boucle on récupère dans G" les proportions
obtenues pour chaque résultat possible. En faisant la somme cumulée
des valeurs de G" on obtient bien la fonction de répartition empirique
pour la loi binomiale. La liste GS se construit par la relation de récur-
rence LP [k +1] = LP [k]/(k +1)∗λ. Comme LP [0] vaut 2tT(−λ),
on montre (par récurrence) que pour tout k de {0, . . . , n} :
λn
LP [n] =
n!
ce qui donne bien par somme cumulée la fonction de répartition théo-
rique de la loi de Poisson de paramètre λ.
def SommeCumulee ( L ) :
L [ i ]=L [ i ]+L [ i −1]
return (L)
def C o m p a r a i s o n B i n o m i a l e P o i s s o n ( l , N, n ) :
LY=[0 f o r i i n r a n g e ( 0 , n +1)]
f o r i i n r a n g e (N) :
kRR
211
a=S i m u l a t i o n B i n o m i a l e ( n , l /n )
LY [ a ]=LY [ a ]+1/N
p l t . p l o t ( SommeCumulee ( LY ) , ’ r ’ )
LP=[np . exp (− l ) ]
LP=LP+[LP [ − 1 ] / ( i +1)∗ l ]
p l t . p l o t ( SommeCumulee ( LP ) , ’ b ’ )
p l t . show ( )
*MMVTUSBUJPO EF MB MPJ GBJCMF EFT HSBOET OPNCSFT
Soit (Xn )n∈N∗ des variables aléaoires mutuellement indépendantes

définies sur un même espace probabilisé et admettant une espérance
et une variance. Soit � > 0. On a :
Loi faible des grands nombres

X1 + · · · + X n
HBK P

− E(X) ≥ � = 0
n→+∞ n
Pour illustrer la loi faible des grands nombres, on tracera entre deux
entiers n1 et n2 la proportion de tirages obtenus sur N tirages dans
l’intervalle donné par le théorème pour un 2TbBHQM choisi. On utilisera
ici la loi de Bernoulli de paramètre p, mais on pourrait adapter très
facilement à toute loi voulue.
-hBMHPSJUINF
Fonction I l l u s t r a t i o n L F G N ( n1 , n2 , N, p , e p s i l o n )
Donnees
n1 , n2 , N, S , i , j , k : e n t i e r s
LS : l i s t e d ‘ e n t i e r s
p, epsilon : flottants
Debut
LS<−−[0 pour i v a r i a n t de 0 à n2−n1 ]
Pour i v a r i a n t de n1 à n2+1
Faire
kRk
212
Pour j v a r i a n t de 0 à N
Faire
S <−−0
Pour k v a r i a n t de 0 à i
Faire
S i random ()<p
A l o r s S<−−S+1
Fin S i
Fin F a i r e
S i | S/ i −p | >= e p s i l o n
A l o r s LS [ i −n1]<−−LS [ i −n1 ]+1/N
Fin S i
Fin F a i r e
Fin F a i r e
T r a c e r ( LS )
Fin
def I l l u s t r a t i o n L F G N ( n1 , n2 , N, p , e p s i l o n ) :
LS=[0 f o r l i n r a n g e ( n1 , n2 +1)]
f o r i i n r a n g e ( n1 , n2+1) :
f o r j i n r a n g e ( 0 ,N) :
S=0
for k in range (0 , i ) :
i f r d . random ()<p :
S=S+1
i f a b s ( S/ i −p)>= e p s i l o n :
LS [ i −n1 ]=LS [ i −n1 ]+1/N
p l t . p l o t ( LS )
p l t . show ( )
kRj
213
#PÔUF Ë PVUJMT
Le module MmKTvX`M/QK fournit les fonctions de simulation sui-

vantes :
donne un résultat suivant la loi
`M/QKnBMi2;2`bU-#V
uniforme sur [[a, b]]
#BMQKBHUM-TV
binomiale de paramètres n et p
;2QK2i`B+UTV
géométrique de paramètre p
TQBbbQMUHK#/V
de Poisson de paramètre λ
De plus, dans chaque cas, on peut rajouter un troisième paramètre
indiquant une longueur l entière. Le résultat sera alors un ndarray de
longueur l dont chaque coefficient a été obtenu par une simulation
(indépendante des autres) de la loi précisée.
« J’ai toujours rêvé que mon ordinateur soit aussi simple à

utiliser que mon téléphone. Ce rêve est devenu réalitéă : je ne
sais plus comment utiliser mon téléphone. »
#KBSOF 4USPVTUSVQ, informaticien danois.
kR9
214
$BMDVMT NBUSJDJFMT
2VFMRVFT PQÏSBUJPOT EF CBTF TVS MFT NBUSJDFT
Commençons par programmer quelques opérations élémentaires sur

les matrices que nous utiliserons par la suite. Nous pourrions évi-
demment recourir aux fonctions du module N UMPY, mais il n’est
pas inutile de savoir programmer des opérations les plus courantes.
On donne ici des fonctions P YTHON permettant de calculer :
• La matrice identité ;
• La trace d’une matrice carrée ;
• La transposée d’une matrice ;
• Le produit de deux matrices.
Les matrices sont ici données sous forme de listes de listes.
def I d e n t i t e ( n ) :
I =[[0 for j in range ( n ) ] for i in range ( n ) ]
I [ i ][ i ] = 1
return I
def T r a c e (A) :
n = l e n (A)
T=0
T=T+A [ i ] [ i ]
return T
def T r a n s p o s e e (A) :
m = l e n (A)
n = l e n (A [ 0 ] )
B= [ [ 0 f o r j i n r a n g e (m) ] f o r i i n r a n g e ( n ) ]
kR8
215
f o r j i n r a n g e (m) :
B[ i ] [ j ] = A[ j ] [ i ]
r e t u r n (B)
def P r o d u i t (A , B) :
m = l e n (A)
n = l e n (A [ 0 ] )
p = l e n (B)
q = l e n (B [ 0 ] )
i f n != p :
print ( ’ erreur :

l e s m a t r i c e s ne s o n t p a s c o m p a t i b l e s ’ )
else :
M= [ [ 0 f o r j i n r a n g e ( q ) ]

f o r i i n r a n g e (m) ]
c o e f f =0
f o r i i n r a n g e (m) :
for j in range (q) :
c o e f f = c o e f f+A [ i ] [ k ] ∗ B [ k ] [ j ]
M[ i ] [ j ] = c o e f f
return M
7BMFVS QSPQSF EF QMVT HSBOE NPEVMF
Pour toute matrice A carrée d’ordre n telle que les valeurs propres
λi de A vérifient |λ1 | > |λi | pour tout i > 1, on a :
h`(An+1 )
HBK = λ1
n→+∞ h`(An )
On va ici tracer les quotients des traces de deux puissances succes-

sives d’une matrice de manière à identifier une valeur approchée de
la plus grande valeur propre de celle-ci. On donnera de plus comme
résultat la dernière valeur obtenue.
kRe
216
-hBMHPSJUINF
Fonction VPMAppr (A , N)
Donnees
A , M1, M2 : m a t r i c e s
N, i : e n t i e r s ,
L : l i s t e de f l o t t a n t s
Debut
M1 <−− A
M2 <−− A^2
L <−− [ Tr (M2) / Tr (M1 ) ]
Pour i v a r i a n t de 0 à N+1
Faire
M1 <−− M1 . A
M2 <−− M1 . A
L <−− L + [ Tr (M2) / Tr (M1 ) ]
Fin F a i r e
Tracer (L)
Retourner L [ −1]
Fin
def VPMAppr (A , N) :
M1=A
M2=P r o d u i t (A , A)
L=[ T r a c e (M2) / T r a c e (M1 ) ]
f o r i i n r a n g e (N+1) :
M1=P r o d u i t (M1, A)
M2=P r o d u i t (M1, A)
L=L+[ T r a c e (M2) / T r a c e (M1 ) ]
plt . plot (L)
p l t . show ( )
r e t u r n L [ −1]
kRd
217
&YQPOFOUJFMMF EF NBUSJDF
On donne ici une fonction qui retourne une valeur approchée de

l’exponentielle d’une matrice A, en calculant les sommes partielles
N
Ak
.
k!
k=0
-hBMHPSJUINF
Fonction E x p o n e n t i e l l e M (A , N)
Donnees
A , M, E : m a t r i c e s
i : entier
Debut
M <−− I d e n t i t e ( l e n (A ) )
E <−− M
Pour i v a r i a n t de 1 à N+1
Faire
M <−− M∗A/ i
E <−− E + M
Fin F a i r e
Retourner E
Fin

Spécification : Cette fonction prend en entrée une matrice A et
un entier N . Elle retourne la somme partielle de rang N de l’expo-
nenielle de A :
N
Ak
k!
k=0
Correction : Si on note Mk les valeurs successives stockées dans

la variable M , on a M0 = In et pour tout entier k inférieur à N
1
on a la relation Mk+1 = k+1 M.A qui implique par une récurrence
1 k
immédiate l’égalité Mk = k! A pour tout entier k inférieur à N .
kR3
218
Comme E contient la somme des Mk successifs, la fonction retourne
bien la somme voulue.
def E x p o n e n t i e l l e M (A , N) :
M=I d e n t i t e ( l e n (A ) )
E=M
f o r i i n r a n g e ( 1 ,N+1) :
M=P r o d u i t (M, A)
f o r i i n r a n g e ( 0 , l e n (A ) ) :
f o r j i n r a n g e ( 0 , l e n (A ) ) :
M[ i ] [ j ] = M[ i ] [ j ] / i
E=E+M
return (E)
#PÔUF Ë PVUJMT
Le module MmKTv contient de très nombreux outils pour travailler

avec des matrices, de type ``v. On peut notamment retenir les fonc-
tions suivantes :
donne un objet, de type ``v
``vUV correspondant à l’entrée (liste ou
liste de listes)
donne la matrice nulle à n lignes
x2`QbUUM-TVV
et p colonnes
donne la matrice identité d’ordre
B/2MiBivUMV
n
i`+2UV donne la trace de la matrice A
donne la transposée de la ma-
i`MbTQb2UV
trice A
donne le produit des matrices A
/QiU-"V
et B
kRN
219
Pour l’exponentielle de matrice on aura cependant recours à une
fonction de la bibliothèque b+BTvXHBMH; :
donne l’exponentielle de la
2tTKUV
matrice A
« Mesurer la progression du développement d’un logiciel à

l’aune de ses lignes de code revient à mesurer la progression de
la construction d’un avion à l’aune de son poids. »
#JMM (BUFT, informaticien américain.
kky
220
1JMFT
1JMFT
On présente ici une structure

structure de
de données
données classique
classique en
en informatique.
informatique.
Nous mettrons en oeuvre
oeuvre cette
cette structure
structure en
en PPYTHON
YTHON en en créant
créant une
une
classe, ce qui donnera un
un exemple
exemple simple
simple de
de programmation
programmationorienté
orienté
objet.
$SÏBUJPO EF MB DMBTTF
DMBTTF 1JMF
1JMF
On appelle pile une collection

collection ordonnée
ordonnéed’éléments
d’éléments(a (a00,,......,,aann))dont
dont
on appelle an le sommet.
sommet. OnOn s’autorise
s’autorise àà effectuer
effectuerles
lesopérations
opérationssui- sui-
vantes sur une pile :
• Tester si la pile est vide
vide ;;
• Prendre le sommet de
de la
la pile
pile ;;
• Retirer l’élément au sommet
sommet dede la
la pile,
pile, dans
dans ce
ce cas
cas aan−1
n−1 devient
devient
donc le nouveau sommet
sommet de
de la
la pile
pile;;
• Ajouter un élément an+1
n+1 qui
qui devient
devient le
lenouveau
nouveausommet
sommetde
delalapile.
pile.
On peut se représenter un
un tel
tel objet
objet sous
sous la
la forme
forme ::
33
12
12
67
67
12
12
avec ici le sommet égal àà 3.

3.
Cette structure de données
données est
est particulièrement
particulièrementadaptée
adaptéeaux
auxproblèmes
problèmes
pour lesquels les dernières
dernières informations
informationsstockées
stockéesseront
serontles
lespremières
premières
à devoir être traitées, puisqu’on
puisqu’on nene peut
peut accéder
accéder de
de manière
manière directe
directe
kkR
kkR
221
qu’au sommet de la pile. On dit pour cela qu’il s’agit d’une structure
last in first out.
Pour définir ces objets en P YTHON, on utilise ici la commande class,
qui permet de créer une structure de données et un ensemble d’opé-
rations ou méthodes possibles avec ceux-ci :
class Pile :
def __init__ ( s e l f ) :
s e l f . elements =[]
def E s t V i d e ( s e l f ) :
i f s e l f . e l e m e n t s ==[] :
r e t u r n True
else :
return False
def A j o u t e r ( s e l f , x ) :
s e l f . e l e m e n t s = s e l f . e l e m e n t s +[ x ]
def R e t i r e r ( s e l f ) :
i f s e l f . EstVide () :
p r i n t ( ’ I m p o s s i b l e de r e t i r e r :

la pile est vide . ’ )
else :
n=l e n ( s e l f . e l e m e n t s )
s e l f . e l e m e n t s= s e l f . e l e m e n t s [ : n −1]
def Sommet ( s e l f ) :
i f s e l f . EstVide () :
p r i n t ( " I l n ’ y a p a s de sommet :

la pile est vide . ")
else :
r e t u r n s e l f . e l e m e n t s [ −1]
On peut alors construire une pile vide en écrivant :

P = Pile ()
kkk
222
et lui ajouter des éléments en utilisant la méthode DQmi2`. Comme
pour toutes les méthodes, la syntaxe est de la forme :
Q#D2iXK2i?Q/2U`;mK2MibV
Ainsi,
P. Ajouter (12)
P. Ajouter (67)
P. Ajouter (12)
P. Ajouter (3)
crée la pile que nous avons représentée précédemment.
2VFMRVFT GPODUJPOT VUJMJTBOU MFT QJMFT
Nous présentons ici quelques fonctions simples typiques du travail

avec les piles. Dans l’ordre, nous programmons :
• Une fonction renversant une pile donnée ;
• Une fonction ou plutôt une procédure d’affichage d’une pile ;
• Une fonction calculant la hauteur d’une pile donnée ;
• Une fonction superposant deux piles données.
Dans chaque cas, on fait bien attention à ce que les piles d’origine
soient inchangées à la fin de la fonction. En effet, la structure sous-
jacente que nous avons prise pour nos piles est la structure de liste
P YTHON.
def R e n v e r s e r (P) :
P1 = P i l e ( )
P2 = P i l e ( )
w h i l e not (P . E s t V i d e ( ) ) :
P2 . A j o u t e r (P . Sommet ( ) )
P. Retirer ()
w h i l e not ( P1 . E s t V i d e ( ) ) :
P . A j o u t e r ( P1 . Sommet ( ) )
kkj
223
P1 . R e t i r e r ( )
r e t u r n P2
def A f f i c h a g e (P) :
P1=R e n v e r s e r (P)
p r i n t ( P1 . Sommet ( ) )
P1 . R e t i r e r ( )
def H a u t e u r (P) :
P1 = P i l e ( )
H = 0
w h i l e not (P . E s t V i d e ( ) ) :
H = H + 1
P. Retirer ()
P . A j o u t e r ( P1 . Sommet ( ) )
P1 . R e t i r e r ( )
return H
def S u p e r p o s e r ( P1 , P2 ) :
P3 = P i l e ( )
P4 = P i l e ( )
P3 . A j o u t e r ( P1 . Sommet ( ) )
P1 . R e t i r e r ( )
P4 . R e t i r e r ( )
P2 . R e t i r e r ( )
P4 . R e t i r e r ( )
r e t u r n P3
kk9
224
2VBUSJÒNF QBSUJF
*/%&9
Index
Python
Que vient faire le nom d’un serpent pour nommer un langage
de programmation ? Un groupe d’humoristes britanniques
anima une émission télévisuelle à la BBC sous le titre de Monty
Python’s Flying Circus entre 1969 et 1974. Celle-ci recueillit
un tel succès qu’elle fut reprise par de nombreuses chaînes
LE SAVIEZ-VOUS ?
étrangères.
Le mathématicien hollandais Guido van Rossum, né en 1956,
s’est enthousiasmé pour cette émission. Son autre passion
kk8l’informatique : dès 1986, il commence à concevoir des
fut
langages de programmation. Trois ans plus tard, il en développe
un nouveau qu’il nomme par humour du nom de la troupe de
comiques. La première version publique voit le jour en 1991.
Très philanthrope, van Rossum a souhaité laisser PYTHON
en licence libre et en open data ; il continue régulièrement
à améliorer son œuvre. Les grandes qualités de ce langage,
en particulier sa simplicité et sa lisibilité, ont permis son
développement au point qu’il devenu l’un des plus répandus
dans le monde.
*OEFY EFT DPNNBOEFT
abs, 21 floor, 22
acos, 22 for, 15
alen, 28 frexp, 22
arange, 27 from, 19
array, 27, 219 fsolve, 32, 105
asin, 22 gcd, 22, 59
atan, 22 geometric, 33, 214
axis, 34 grid, 34
bin, 21, 62 help, 21
binomial, 33, 214 hex, 21, 62
choice, 33 id, 9
chr, 21 identity, 27, 219
clf, 34 if, 15
coef, 201 import, 19
complex, 21 in, 67
cos, 22 input, 21
cosh, 22 int, 21, 64
degree, 201 inv, 31
degrees, 22 leggauss, 206
deriv, 201 len, 21
det, 31 linspace, 27
divmod, 21 list, 21
divmode, 52 log, 22
dot, 31, 219 log10, 22
e, 22 log2, 22
eig, 32
matrix, 31
eigvals, 32 max, 21, 75
empty, 27 mean, 30, 77
eval, 21 median, 82
exp, 22 min, 21
factorial, 22 min, 75
float, 21
kke
226
random_integers, 214
randrange, 33
range, 10, 21
roots, 201
round, 21
minimize_scalar, 93 type,
savefig,21 34
ndim, 28 uniform,
set, 21 33
normal, 33 var, 30,28
shape, 79
oct, 62 while,
sin, 22 15
odeint, 33, 118 zeros,
sinh, 2227, 219
ones, 27 size, 28
ord, 21 solve, 32
pi, 22 solve_triangular, 124
plot, 34 sorted, 21, 154
poisson, 33, 214 sqrt, 22
polynomial, 201 std, 79
pow, 21, 22, 46 str, 21
power, 31 sum, 21, 42
print, 21 tan, 22
prod, 30, 42 tanh, 22
quad, 32 trace, 31, 219
radians, 22 transpose, 31, 219
randint, 33 trapz, 111
minimize_scalar,
random, 33 93 type, 21
ndim, 28 uniform, 33
random_integers, 214 kkd
normal,
randrange,33 33 var, 30, 79
oct,
range,6210, 21 while, 15
odeint, 33, 118 zeros, 27, 219
roots, 201
ones, 27
round, 21
ord, 21
savefig, 34
pi, 22
set, 21
plot, 34
shape, 28
poisson, 33, 214
sin, 22
polynomial,
sinh, 22 201
pow, 21,
size, 28 22, 46
power,
solve, 3231
print, 21
solve_triangular, 124
prod,
sorted, 21,42154
30,
quad,
sqrt, 2232
radians,
std, 79 22
randint,
str, 21 33
random,
sum, 21, 3342
random_integers,
tan, 22 214
randrange,
tanh, 22 33
range, 10,219
trace, 31, 21
Index
transpose,
roots, 201 31, 219
round, 21
trapz, 111
savefig, 34
set, 21 227
kkd
shape, 28
sin, 22
*OEFY HÏOÏSBM
tri
récursif, 136, 144
selection, 148
type de données, 2
*OEFY HÏOÏSBM
*OEFY
*OEFY HÏOÏSBM
HÏOÏSBM
uint8, 155
algorithme *OEFY HÏOÏSBM
diviseurs premiers, 54
d’Euclide, 57 division euclidienne,
valeur propre, 216 51, 198
d’Euclide étendu, 194, 199 variance, 77
d’exponentiation rapide, 43
algorithme écart-type,premiers,
diviseurs 79 54
algorithme
de Dijkstra,57169
d’Euclide,
algorithme diviseurs
diviseurs premiers,
exponentielle
division 54
de matrice,
équationeuclidienne,
premiers,
différentielle 218
5451, 198
algorithme
algorithme diviseurs
diviseurs premiers,
premiers, 54
54
algorithme
d’Euclide,
de
algorithme Gauss,
d’Euclide
d’Euclide, 57 57
129
étendu,
57 194, 199 diviseurs
division
diviseurs
division premiers,
euclidienne,
premiers, 541,
d’ordre54
euclidienne,
scalaire 51, 198
51,112
198
d’Euclide,
d’Euclide, 57 division
division euclidienne,
euclidienne, 51,
51, 198
198
d’Euclide
d’Euclide,
de
d’Euclide
d’Euclide, étendu,
57
Hörner,étendu,
d’exponentiation 49
57 194, 199
rapide,
194, 199
43 division euclidienne,
scalaire
division 79d’ordre
1602,
euclidienne,
écart-type,
filtrage gaussien, 51,118
51, 198
198
d’Euclide
d’Euclide étendu,
étendu, 194,
194, 199
199
d’exponentiation
d’Euclide
arbred’Euclide
binaire,
de 185
Dijkstra,
d’exponentiationétendu,
169
étendu, rapide,
194,
rapide,
194, 43
199
43
199 écart-type, 79
vectorielle
exponentielle
écart-type, d’ordre 1,
79 de matrice, 218 115
d’exponentiation
d’exponentiation rapide,
rapide, 43
43 floutage, 160
écart-type, 79
d’exponentiation
de
arc, 167 Dijkstra,
d’exponentiation
de Gauss,
Dijkstra, 169
129
169 rapide,
rapide, 43
43 écart-type,
écart-type,
exponentielle79
79 de matrice, 218
de
de Dijkstra,
Dijkstra, 169
169 écart-type,
exponentielle
fonction
exponentielle79 de matrice,
de matrice, 218
218
arête,de167
de Dijkstra,
Gauss,
Hörner,
Dijkstra,
Gauss, 169
129
49
169
129 exponentielle
exponentielle
φ d’Euler, de matrice,
de192
matrice, 218
218
de
de Gauss,
Gauss, 129
129 exponentielle
filtrage de
gaussien, matrice,
160 218
arbre de
de Hörner,
Gauss,
binaire,
Hörner,
Gauss, 185 49
129
49
129 filtrage gaussien,
définition, 17160
bit deparité,
dede Hörner,
Hörner,164 49
49 floutage,
filtrage 160
filtrage gaussien,
gaussien, 160
160
arbre
arc,
arbre167binaire,
de Hörner,
binaire,
de Hörner, 185
185 49
49 filtrage
filtrage gaussien,
gaussien,
récursive,
floutage, 160 18160
160
arbre
boucle
arbre binaire,
binaire, 185
185 filtrage
fonction
floutage,
floutage, gaussien,
160
160 160
arc,
arbre
arc,
arbre167
arête,
167binaire,
167
binaire, 185
185 15 floutage,
fusion,
floutage, 160
144
160
arc,
arc, 167
conditionnelle, fonction
φ d’Euler,
floutage,
fonction 160 192
arête,167
arc, 167
arête,
arc, 167167
167 fonction
fonctiond’Euler, 192
arête,
arête,
bit 167
inconditionnelle,
167
de 167
parité, 164 15 fonction
φ
définition,
fonction
φ
φ d’Euler,
d’Euler, 17
192
192
arête,
arête, 167 φ d’Euler,
d’Euler,
définition, 192
192
17
bit de
boucle
bit parité, 164 graphe,
φ
φ 167
récursive,
d’Euler,
définition,
définition, 18
192
17
17
bit de
bit de parité,
de parité,de
chiffrement
parité,
164
164
164 Vigenère, 161 définition,
récursive,
définition,
fusion, 144
pondéré, 17
18
17
168
bit de
boucle
bit parité,
de parité, 164
conditionnelle, 15 récursive,
définition,
récursive, 1818
17
18
boucle
boucle
classe,
boucle 221 164 15
conditionnelle,
récursive,
fusion, 144
récursive,
fusion, 144
récursive, 18
18
boucle
boucle inconditionnelle,
conditionnelle,
conditionnelle, 15
15 15 fusion,
fusion, 144
144
clé conditionnelle,
inconditionnelle,
conditionnelle, 15 15 15
1515 fusion,
fusion,
graphe, 144
144
167
inconditionnelle,
conditionnelle,
inconditionnelle,
privée, 195Vigenère, 15 Hörner, 49
inconditionnelle,
chiffrement de
inconditionnelle, 15 161
15 graphe, 167
pondéré,
inconditionnelle,
publique,
chiffrement de 195Vigenère,15 161 graphe,
graphe,
graphe, 167 168
167
167
classe, 221
chiffrement
chiffrement de de Vigenère,
de Vigenère, 161
Vigenère, 161
161 graphe,
graphe, 167
pondéré,
167
pondéré,
intégration 168
168
numérique, 204
chiffrement
chiffrement
code
classe,de221 de
Hamming, Vigenère,
164 161 pondéré,
pondéré, 168
168
clé
chiffrement
classe, 221
classe, 221
221 de Vigenère, 161 pondéré,
pondéré, 168
168 rectangles, 106
classe,
clé
classe,
colonie 221
de fourmis, 175 Hörner, 49
méthode des
clé privée,
classe,
clé 221 195 Hörner, 49
clé
clé privée,
complexité,
publique,
privée, 195
26
195195 méthode
Hörner,
Hörner, 49 des trapèzes, 108
49
clé privée,
privée, 195
195 Hörner,
Hörner, 49
49
privée,
publique,
concaténation,
code privée, 195195
11 164
195195
de Hamming,
publique, Hörner, 49
intégration numérique, 204
publique,
publique, 195
195 intégration
méthode numérique, 204
des rectangles,
code publique,
de
contours, Hamming,
code publique,
colonie
code de de
de 157
Hamming,
Hamming,
195
195 164
fourmis, 164
175
164
intégration
intégration numérique,
lissage, 160
intégration numérique,
numérique, 204 106
204
204
code
code
coloniede
de
conversion Hamming,
Hamming,
de fourmis, 164
164
175 intégration
loi méthode
intégration
méthode numérique,
des
numérique,
des 204 108
rectangles,
204
trapèzes,
rectangles, 106
106
complexité,
code
colonie
coloniede de
de 26
Hamming,
fourmis,
fourmis, 164
175
175 méthode des
méthode des rectangles,
rectangles, 106
106
coloniede
complexité,
colonie de
la
de fourmis,
base
26
fourmis,
b 175
vers la
175 base 10, 62 méthode
binomiale,
méthode des
des rectangles,
trapèzes,
33, 208
rectangles,
trapèzes, 106
108
106
108
concaténation,
complexité,
colonie
complexité,de 26 11
fourmis,
26 175 méthode
méthode des
des trapèzes,
trapèzes, 108
108
complexité,
de la 157
complexité,
concaténation, 26
base
26 10 vers la base b, 59 méthode
faible
méthode des
des trapèzes,
grands
160 des trapèzes, 108 108
nombres,
contours,
complexité,
concaténation,
concaténation, 26 11
11
11
lissage,
concaténation,
crible
contours,
concaténation,157 11
d’Erathostène,
11 190 lissage, 160212
conversion
contours, 157
concaténation,
contours, 157 11 loi
lissage,
lissage, 160
160
géometrique, 33, 209
contours,
cryptage, 157
161 lissage,
lissage, 160
160
loi binomiale,
conversion
contours,
conversion
contours, 157
de la 157
base b vers la base 10, 62 lissage,
loi 160 3333, 208
OEFY HÏOÏSBM
conversion
conversion
de
conversion
de la base
de la
conversion la base
base
bb vers
10 versla
vers
vers
base
base10,
lalabase
la base
62
b, 59
10,
10, 62
62
loi
loi normale,
loi faible
loi binomiale,des 33,
binomiale,
binomiale, 33,
33,
208
grands
208 nombres,
208
dichotomie,
criblede
de la
la base
base bbb vers
94 10
d’Erathostène, vers
versla
lala
190 base
base
base10,
10,
b, 62
62
59 binomiale,
uniforme,
faible
faible des
binomiale,
212
des
binomiale,
33,
33, 208
207
grands
33, 208
grands
33, nombres,
208 nombres,
de
de la
la base
base 10
10 b vers
verslala
vers labase
base10,
base b, 62
59
b, 59 faible
faible des
des grands
grands nombres,
nombres,
crible de
de
cryptage, la base 10
d’Erathostène,
la base
161 10 vers
vers la
190
la base
base b,
b, 59
59 faible 212
géometrique,
faible des
212
des 33,
grands
grands209 nombres,
nombres,
cribleded’Erathostène,
crible d’Erathostène,
la base 10 vers190 190
la base b, 59 212
212
géometrique, 33, 209
crible
cryptage,
crible d’Erathostène,
161
d’Erathostène, 190
190 kk3 212
normale,
géometrique,
212
géometrique,33 33,
33, 209
209
cryptage,
crible
cryptage, 161
d’Erathostène,
161 190 géometrique,
géometrique, 33,
33, 209
209
cryptage,
dichotomie,
cryptage, 16194 normale, 33
uniforme,
géometrique,
normale, 33
33, 33,
207209
cryptage, 161 161 normale,
normale, 33 33
dichotomie,
diviseurs
dichotomie, 94
premiers,
94 54 uniforme,
normale,
uniforme,
normale, 33,
33
33,
33 207
207
dichotomie,
dichotomie, 94 94 uniforme,
uniforme, 33,33, 207
207
dichotomie,
dichotomie, 94
94
division euclidienne, 51, 198 uniforme,
uniforme, 33,33, 207
207
kk3
4, 199 kk3
kk3
kk3
kk3
ide, 43 écart-type, 79 kk3
kk3 kjy
exponentielle de matrice, 218
228
filtrage gaussien, 160
floutage, 160
fonction
matrice, 27, 215 problème du voyageur de com-
d’adjacence,
matrice, 27, 215 168 problème merce, 175
du voyageur de com-
matrice, 27,
27, 215
d’adjacence,
inverse,
matrice, 31 168
215 problème
produit
problème du
d’une
merce, voyageur
du liste de réels,
175
voyageur de
de40com-
com-
d’adjacence, merce, 175
matrice, 31 31168
27, 215
transposée,
d’adjacence,
inverse, 168 produit
problème du voyageur de40com-
d’une
programmation liste
merce, de
175 réels,
orientée objet, 221
inverse, produit
produit d’une liste de
de réels, 40
7331
d’adjacence,
maximum,
inverse, 31 31168
transposée, programmation
puissance merce,
d’une liste175 réels,
orientée 40 221
objet,
transposée, programmation orientée objet,
40 221
inverse,
d’une 7331 31
fonction,
transposée,
maximum, 31 91 produit
puissance
d’und’une
programmationréel,liste
43 de réels,
orientée objet, 221
maximum, 73
transposée, puissance
programmation
puissance orientée objet, 221
médiane,
d’une79,
maximum, 7314131 91
fonction, d’un réel, 43
d’une
méthode
médiane,
d’une79,
maximum, fonction,
73141 91
fonction, 91 d’un
d’un réel,
recherche
puissance réel, 43
43
médiane,
de 79, 141
Lagrange, d’un
recherche mot dans une chaîne, 85
méthode
d’une
médiane, 141 103
fonction,
79, 91 d’un
recherche réel, 43
méthode
de Lagrange,
d’Euler, 113 103 d’un pivot,
recherche mot dans125une chaîne, 85
médiane,
méthode 79, 141 d’un
de
de Lagrange,
Gauss,113
Lagrange,
d’Euler,
méthode 127103
103 d’un mot
recherche pivot,
mot dans
élément
dans une
une chaîne,
125dans 85
une liste,
chaîne, 85
d’Euler, 113 d’un pivot,
d’un 65,
mot 69
pivot, 125
dans
élément une chaîne,
125dans 85
une liste,
Lagrange,
de Newton,
Gauss,113
d’Euler, 127103204
100, d’un élément
de
des Gauss, 127
rectangles,
d’une
d’un 65, 69 125dans
séquence
pivot,
élément dansune
dans une liste,
une liste,
de Newton,
d’Euler,
Gauss, 113 100,106
127 204 65,
83 69
de d’une
d’un 65,séquence dans
69 dans une une liste,
desNewton,
de trapèzes,
Newton, 100,
rectangles,
Gauss, 127108
100, 204
106
204 d’une
élément
séquence dans
des rectangles, 106 dichotomique
83
d’une65, 69
séquence dans une
d’un une liste,
élément,
liste,
de Newton,
des
moyenne, 75 100,
rectangles,
trapèzes, 108 204
106 83
67
dichotomique
83 d’un élément,
des rectangles,
trapèzes, 108 d’une séquence
dichotomique dans
d’un une liste,
des
moyenne, trapèzes,
75 108106 du zéro
67
dichotomique
83 d’un élément,
d’une fonction élément,
moyenne,
des de
moyenne, 75
trapèzes,
75 108 du 67
méthode
zéro
67 d’unede Newton,
fonction 100
niveaux gris, 155 dichotomique
du zéro d’une d’un élément,
moyenne, 75 duméthode
zéro
67 d’unede fonction
du point fixe,100
Newton,
fonction 99
niveaux premier,
nombre de gris, 155
53, 54, 190 méthode de Newton,
niveaux de gris, méthode
dupar d’unedu
zérodichotomie, point94fixe,100
de fonction
Newton, 99
100
niveaux
noyau gris, 155
deconvolution,
nombredepremier, 155
53, 54, 190
158 méthode du point
nombre RSA, 195 méthode de
par dichotomie, point94fixe,
du Newton, 99
fixe,100
99
noyau depremier,
niveaux
nombre 53,
53, 54,
deconvolution,
gris, 155
premier, 54, 190
190
158 par
par dichotomie,
méthode du
dichotomie, 94
point
94 fixe, 99
noyau de convolution, 158 RSA, 195
nombre
noyau depremier, 53,
convolution, 54, 190
158 RSA,
objet RSA, 195
somme d’une
par
195 liste de réels,
dichotomie, 94 40
noyau de convolution,
objetindexable, 3 158 somme de contrôle,
d’une liste de164
réels, 40
RSA,
somme 195
objet
objetmutable,
indexable,3 3 somme d’une
sommet, de167 liste
liste de
contrôle,
d’une réels,
réels, 40
de164 40
somme de contrôle, 164
objetindexable,
indexable,3 33
mutable, suite
somme
sommet,récurrente,
d’une
de167 89de164
liste
contrôle, réels, 40
sommet, de167
objetmutable,
mutable,233 3
indexable,
itérable, somme
suite d’ordre
sommet,
suite
1, 8889 164
contrôle,
récurrente,
167
récurrente,
objet
objetmutable,
itérable,6923
occurrence, système
sommet, 1671, 8889
d’équations
suite d’ordre
récurrente, 89 linéaires, 127
itérable, 22 71 suite d’ordre
système 1,
1, 88
récurrente,
d’équations
triangulaire,
d’ordre 8889
122linéaires, 127
objet nombre
occurrence, d’,
itérable,69 système d’équations
occurrence,
OPEL, 25 69
itérable,
nombre
occurrence, 692 71
d’, d’ordre
système 1, 88122linéaires,
d’équations
triangulaire, linéaires, 127
127
nombre d’, triangulaire,
tableau, 27 122
occurrence,
OPEL, 25 69
nombre d’, 71
71 système d’équations
triangulaire, 122linéaires, 127
OPEL, 25 coupe,
tableau, 27 29 122
triangulaire,
OPEL, nombre
25136d’, 71
partition, tableau, 27
OPEL, 25 tas, coupe,
185
tableau, 27 29
partition,
PGCD, 57136 test coupe,
tableau,
de 27 29
primalité,
coupe,
tas, 185 29 53
partition,
partition,57136 tas,
phéromones,
PGCD,
PGCD,
136176 tas, 185
test coupe,
de
trace,
185 29 53
primalité,
31, 215
PGCD, 22157
partition,57136176
phéromones,
pile, test
tas, de
test 185 primalité,
transposée,
de31,
trace, 215 53
primalité,
215 53
phéromones,
PGCD, 57 176
phéromones,
pile,
pivot,221
136 176 trace, 31, 215
pile, 221 test
tri de31,
trace, primalité,
transposée, 215 53
215
phéromones,
136 176
pile, 221
pivot,
pixel, 155 transposée,
trace,
tri bulles,
31, 215
transposée, 215
150
215
pivot,
pile, 136
221
pivot,court
pixel,
plus 136 chemin, 169
155 tri en place,
bulles,
transposée,
tri 150
215 140
pixel,
pivot,
plus
poids, 155
136
pixel,court
155
168 chemin, 169 bulles, 150
en place,
tri fusion,
bulles, 144
150140
plus
plus court
pixel,
poids, 168 chemin,
155
court
polynôme, 47, 197 169
chemin, 169 en
en place,
bulles,
par 150140
insertion,
place, 140 134
fusion, 144
poids,
plus 168
poids, 168 47, 197 169
court
polynôme,
polynômes chemin, fusion,
en
par place,144140 134152
insertion,
énumération,
fusion, 144
polynôme,
poids, 47,
47, 197 par insertion,
185 134
de168
polynôme,
polynômes Legendre,197202 fusion,
par 144
insertion,
énumération,
tas, 134152
polynômes
polynôme,
polynômes 47,
de Legendre, 197202 par
par énumération,
185 134152
insertion,
énumération,
tas,
rapide, 136 152
orthogonaux,
Index
de
de Legendre,
polynômes Legendre, 202
orthogonaux, 202 par
par tas, 185
énumération,
tas, 136
rapide, 185 152
orthogonaux,
de
orthogonaux, 202
Legendre, 202
202 rapide,
par tas, 136
rapide, 185
136
kkN
orthogonaux, 202 rapide, 136
kkN
kkN
229
kkN
kkN
tri
récursif, 136, 144
selection, 148
type de données, 2
tri uint8, 155

récursif, 136, 144
selection, 148 valeur propre, 216
type de données, 2 variance, 77
uint8, 155 équation différentielle

scalaire d’ordre 1, 112
valeur propre, 216 scalaire d’ordre 2, 118
variance, 77 vectorielle d’ordre 1, 115
équation différentielle
vectorielle d’ordre 1, 115
kjy
kjy
230
P R É P A S S C I E N C E S
Une vision claire des savoirs, une mobilisation
rapide des connaissances et des compétences sont
les atouts indispensables à la réussite en prépa.
Ce formulaire d’Informatique Pour Tous (IPT) répond
parfaitement à ces exigences.
Il présente de façon synthétique l’intégralité du programme
d’IPT des classes préparatoires aux grandes écoles scientifiques
première et deuxième années.
On y trouvera d’abord une base de connaissances théoriques

indispensables en algorithmique, en programmation et pour les
bases de données.
Tous les algorithmes et scripts Python des programmes de première et
deuxième années, classés par thème, sont ensuite détaillés et analysés.
Finalement, deux index très précis (un index général et un index
des commandes Python) permettent de trouver rapidement la
notion cherchée.
Conçu pour appréhender tout le programme d’IPT en un clin d’œil, ce

formulaire est le compagnon idéal pour la préparation des devoirs, les
séances de travaux pratiques d’informatique, une ressource précieuse
pour les TIPE mais surtout pour accompagner les révisions avant les
concours.
Il complète intelligemment les ouvrages de la collection Prépas Sciences,
qui permettent une acquisition solide des connaissances.
-:HSMDOA=UW[XY[:

Informatique Pour Tous: Scientifiques

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Informatique Pour Tous: Scientifiques

Transféré par

Droits d'auteur :

Formats disponibles

CPGE

scientifiques Nicolas Nguyen

Retrouvez tous les titres de la collection

La réussite en prépa nécessite une acquisition solide des connais-

Ces thèmes sont traités en 20 chapitres (10 de première année et 10

2 Programmation Partie en Python

2 Programmer avec les entiers 51

3. Recherche d’élément dans uneBp liste ...................................................65

11. Algorithmes de tri .............................................................................134

Index des commandes ......................................................................... 226

#"4& %& $0//"*44"/$&

parle encore de l’ordination des prêtres.

/PNCSFT MJTUFT UVQMFUT DIBÔOFT EF DBSBDUÒSFT

-FT EJGGÏSFOUT UZQFT

On peut distinguer deux types d’objets, les simples et les composés.

Il s’agit essentiellement de types numériques.

bool un booléen peut être h`m2 ou 6Hb2

-FT UZQFT TJNQMFT

a+b somme des deux nombres (int,ﬂoat,complex)

a==b test d’égalité, renvoie un booléen

int(a) convertit en entier un ﬂottant ou une chaîne

-FT UZQFT DPNQPTÏT

• Une liste est une suite d’éléments quelconques (pas nécessaire-

retourne la longueur de  (liste, t-uplet, chaîne,

opération de concaténation, juxtapose les deux

teste l’appartenance d’un objet à  (liste, t-uplet,

[a,b,c] crée la liste d’objets - #- +

/PUJPO EF WBSJBCMF FO 1ZUIPO

Pour mémoriser une valeur, on la stocke en mémoire. On représente

"GGFDUBUJPO EhVOF WBMFVS Ë VOF WBSJBCMF

Déclaration d’une variable

Aﬀectation d’une variable

Pour modiﬁer la valeur d’une variable, on utilise l’opérateur d’affec-

Dans une affectation, on commence d’abord par évaluer l’expression

P YTHON permet de réaliser, des affectations simultanées de plu-

En particulier, il est aisé d’échanger le contenu de plusieurs variables

0QÏSBUJPOT TVS MFT WBSJBCMFT

Opérateurs avec assignation

Il est très fréquent d’avoir à incrémenter une variable, c’est-à-dire à

Égalités structurelle et physique

Pour tester l’égalité de deux objets,  et # on a vu l’opérateur de

Pour construire une liste, plusieurs manières sont possibles.

L=[] ou L=list() crée la liste vide

crée la liste de M entiers consécu-

Remarque : Comme les listes sont des séquences d’objets de tous

On peut également utiliser des tableaux h(B-D) du type M/``v de

0QÏSBUJPOT TVS MFT MJTUFT

Opérations communes pour les objets composés

len(L) retourne la longueur de la liste G

Accès aux éléments et extraction de sous-liste

L[i] accède à l’élément d’indice B de la liste G

Aﬀectation à un élément ou à un bloc d’éléments

L[i]=a remplace la valeur du terme d’indice B de la liste G

Copie d’une liste

M=L[ : ] crée une copie de la liste G

«Nous ne savons pas où nous allons, mais du moins il nous

"MBO 5VSJOH, mathématicien anglais.

4USVDUVSFT TÏRVFOUJFMMFT DPOEJUJPOOFMMFT JUÏSB

Cinq types d’instructions

On appelle instruction tout ordre de modiﬁcation de l’état courant

En algorithmique, on délimite les groupes d’instructions par des mots

Une instruction conditionnelle n’est éxécutée que si une condition

Test avec alternative

/PNCSFT MJTUFT UVQMFUT DIBÔOFT EF DBSBDUÒSFT

bool un booléen peut être h`m2 ou 6Hb2

retourne la longueur de (liste, t-uplet, chaîne,

teste l’appartenance d’un objet à (liste, t-uplet,

[a,b,c] crée la liste d’objets - #- +

Pour tester l’égalité de deux objets, et # on a vu l’opérateur de

On peut également utiliser des tableaux h(B-D) du type M/``v de

4USVDUVSFT TÏRVFOUJFMMFT DPOEJUJPOOFMMFT JUÏSB

Si est un tableau unidimensionnel de nombres, et f est une fonction

Le module HBMH; de N UMPY est riche de nombreuses fonctions. En

la.inv(A) retourne l’inverse d’une matrice carrée

Le module KiTHQiHB#XTvTHQi permet de tracer des graphiques dans