Cours d’Informatique pour Tous

2021 –

Jules Svartz
Lycée Masséna
 Lycée Masséna

Svartz Page 2/210

 Lycée Masséna

Préambule

Ces notes de cours sont issues du cours d’informatique commune (IPT) subi par les élèves du lycée Masséna des
classes de première année MPSI (831), PCSI (833) et de deuxième année MP*, MP, PC*, PC, depuis l’année 2021 en
première année et 2022 en deuxième année. Il sera mis à jour régulièrement !
Le cours présenté ici est très détaillé, et tous les points ne sont pas nécessairement abordés en classe : il se veut
utile autant pour l’élève qui veut un récapitulatif que pour celui qui souhaite aller plus loin.
Le polycopié se divise en 7 parties, le programme de première année couvrant les quatre premières, le programme
de seconde année les autres.
— La première partie est dévolue à l’« initiation ». Elle se subdivise en 4 chapitres :
— Le chapitre 0 est un chapitre d’introduction à l’informatique, il présente un point de vue historique sur le
développement de cette discipline, les principaux éléments constitutifs d’un ordinateur et le rôle du système
d’exploitation. Ce chapitre a disparu du nouveau programme, mais il forme une introduction historique
importante à la discipline, et sera sûrement traité encore les années à venir. Le cours présenté ici est
plutôt présenté en fin d’année, par choix pédagogique : il est en effet plus facile d’expliquer précisément le
comportement d’un micro-processeur à des élèves qui savent déja programmer et ont une connaissance du
système de numération binaire.
— Le chapitre 1 présente de manière détaillée les éléments au programme concernant la programmation en
Python. Il est en pratique présenté peu à peu en cours et en TP, parallèlement aux chapitres qui suivent.
— Le chapitre 2 présente la représentation des nombres entiers dans différentes bases, en particulier en binaire.
Les algorithmes de changement de base, quoique non au programme, sont un prétexte pour commencer à
faire des boucles et utiliser des listes.
— Le chapitre 3 est normalement au programme au second semestre, mais il me semble intéressant de le
traiter tôt dans l’année, en parallèle des travaux pratiques. Il donne les outils pour l’analyse théorique
des algorithmes (terminaison / correction / complexité). C’est un chapitre crucial où sont présentés les
algorithmes « basiques » au programme de première année : parcours de listes, recherche dichotomique ou
de motif dans une chaîne de caractères...
— La deuxième partie (au programme officiel traitée uniquement sous forme de travaux pratiques) présente :
— au chapitre 4, les techniques gloutonnes en algorithmique. Le chapitre est volontairement court pour laisser
des exemples en travaux pratiques.
— au chapitre 5, la récursivité. On donne quelques éléments de preuve de programmes dans ce contexte.
— La troisième partie donne quelques compléments de Python. Elle se découpe en 3 chapitres :
— Le chapitre 6 se concentre sur la représentation des nombres. On se restreint maintenant au binaire, et on
explique les rudiments de calculs effectués par un processeur, avec des registres de taille fixe. On présente
aussi la représentation usuelle des nombres flottants.
— Le chapitre 7 présente les méthodes pour lire un fichier textuel en Python, ainsi que la création d’un tel
fichier. C’est l’occasion de revenir sur les chaînes de caractères !
— Le chapitre 8 présente les modules usuels en Python, il fera l’objet d’un ou deux TP(s).
— La quatrième partie est l’occasion de mettre en pratique les techniques vues précédemment.
— On présente d’abord le tri de données, problème essentiel en informatique. On a découpé le traitement des
tris en deux parties, chapitre 9 pour les tris quadratiques, ainsi que le tri par comptage, chapitre 10 pour
les tris efficaces (tri fusion, tri rapide).
— Un bref chapitre 11 présente la notion de jeu de tests pour un programme.
— Enfin, on étudie les bases des graphes dans le chapitre 12. L’accent est porté sur le parcours de graphes, le
programme ayant en ligne de mire l’algorithme de Dijkstra et sa variante A⇤ .

Svartz Page 3/210

 Lycée Masséna

— La partie 5 présente les bases de SQL et de l’algèbre relationnelle.

— Le chapitre 13 donne le vocabulaire et les premières requêtes SQL, en ce concentrant sur une seule base ;
— Le chapitre 14 introduit les liens entre relations.
— La partie 6 étend les techniques gloutonnes vues en premières années pour résoudre des problèmes par program-
mation dynamique.
— Le chapitre 15 donne une implémentation possible en Python de la structure de dictionnaires (avec des
listes Python), via des fonctions de hachage. On explique en particulier comment résoudre les collisions, et
comment une structure dynamique permet de justifier la complexité O(1) que l’on attribue aux opérations
de dictionnaire en Python.
— Le chapitre 16 présente les techniques de programmation dynamique proprement dites.
— Enfin, la septième partie donne une introduction à l’apprentissage (supervisé ou non), ainsi qu’à la théorie des
jeux.

Licence. Cette œuvre est mise à disposition sous licence Attribution - Partage dans les Mêmes Conditions 2.0 France.
Pour voir une copie de cette licence, visitez http://creativecommons.org/licenses/by-sa/2.0/fr/ ou écrivez à
Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.

Svartz Page 4/210

TABLE DES MATIÈRES Lycée Masséna

Table des matières

I Initiation 11
0 Ordinateurs, Systèmes d’exploitation et Python 13
0.1 Qu’est ce qu’un ordinateur ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
0.1.1 Turing et ses machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
0.1.2 Prémices aux ordinateurs et modèle de Von Neumann . . . . . . . . . . . . . . . . . . . . . . . 15
0.1.3 Le rôle de chaque élément. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
0.1.4 Avantages et inconvénients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
0.1.5 De nos jours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
0.1.6 Ordres de grandeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
0.2 Le système d’exploitation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
0.2.1 Le multitâche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
0.2.2 Identification des utilisateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
0.2.3 Organisation des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
0.2.4 Droits d’accès . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
0.3 Le langage Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

1 Programmation en Python 23
1.1 Types simples et expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.1.1 Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.1.2 Entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
1.1.3 Flottants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.1.4 Booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.2.1 Identificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.2.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
1.3 Structures de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.3.1 Python et l’indentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.3.2 Instruction conditionnelle if/else (si/sinon) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
1.3.3 Boucle conditionnelle while (tant que) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.3.4 Boucle inconditionnelle for... (pour...) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.3.5 Break et Continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
1.3.6 Boucles imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.4 Structures de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.4.1 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.4.2 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.4.3 Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
1.4.4 Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
1.5 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.5.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.5.2 Notions et syntaxe de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.5.3 Variables locales et globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
1.5.4 Références vers des objets mutables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
1.5.5 Une fonction : un objet comme les autres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

Svartz Page 5/210

TABLE DES MATIÈRES Lycée Masséna

2 Entiers dans différentes bases 45

2.1 Écriture dans une base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.1.1 Rappels sur la base 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.1.2 Généralisation à une base quelconque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
2.1.3 Généralisation à des bases supérieures à 10. Hexadécimal . . . . . . . . . . . . . . . . . . . . . 46
2.1.4 Histoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
2.2 Changement de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.2.1 Si l’on sait calculer dans la base de départ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.2.2 Si l’on sait calculer dans la base d’arrivée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
2.2.3 Un cas particulier : l’une des bases est une puissance de l’autre . . . . . . . . . . . . . . . . . . 48

3 Analyse d’algorithmes 51
3.1 Terminaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.1.1 Quelques exemples, exponentiation rapide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.1.2 Variant de boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.2 Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.2.1 Correction des boucles while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.2.2 Correction des boucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.2.3 D’autres exemples : parcours linéaires de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.2.4 Recherche efficace dans une liste triée : recherche dichotomique . . . . . . . . . . . . . . . . . . 56
3.3 Complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.3.1 Introduction et tri par sélection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.3.2 Complexité : définitions et méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.3.3 Applications aux algorithmes vus précédemment . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.3.4 Quelques ordres de grandeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.4 Recherche d’un motif dans une chaîne de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

II Techniques algorithmiques 63
4 Algorithmes gloutons 65
4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4.2 Principe des algorithmes gloutons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.3 Maximisation d’activités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.3.1 Un algorithme optimal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.3.2 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.4 Rendu de monnaie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.4.1 Énoncé du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.4.2 Choix glouton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.4.3 Optimalité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

5 Récursivité 69
5.1 Principes de la récursivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.1.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.1.2 La pile d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.1.3 D’autres exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.1.4 Limites de la récursivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.1.5 Avantage de la récursivité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.2 Terminaison, correction et complexité d’une fonction récursive . . . . . . . . . . . . . . . . . . . . . . . 74
5.2.1 Terminaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
5.2.2 Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.2.3 Complexité des fonctions récursives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

III Compléments de Python 77

6 Représentation des entiers relatifs, représentation des flottants 79
6.1 Représentation des entiers relatifs en binaire, additions . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
6.1.1 Entiers naturels de taille fixée et additions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

Svartz Page 6/210

TABLE DES MATIÈRES Lycée Masséna

6.1.2 Entiers relatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

6.1.3 En pratique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
6.2 Représentation des nombres réels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.2.1 Représentations des nombres dyadiques en binaire . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.2.2 Nombres flottants normalisés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
6.2.3 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.3 Arrondis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86

7 Lecture et écriture dans des fichiers 89

7.1 print et input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
7.2 Fonctions pour les fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

8 Modules usuels 93
8.1 Module math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
8.1.1 Importation du module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
8.1.2 De l’aide ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
8.2 Module numpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
8.3 Module matplotlib. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
8.3.1 Options pyplot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
8.3.2 Quelques exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
8.4 Module scipy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
8.4.1 Résolution d’équations numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
8.4.2 Intégration de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
8.4.3 Intégration d’équations différentielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
8.5 Quelques autres modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

IV Algorithmique avancée 103

9 Algorithmes de tris naifs 105
9.1 Introduction : le problème du tri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
9.2 Tri par sélection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
9.3 Tri à bulles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
9.4 Tri par insertion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
9.5 Conclusion sur les tris par comparaisons quadratiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
9.6 Un tri qui n’est pas un tri par comparaisons : le tri par comptage . . . . . . . . . . . . . . . . . . . . . 110

10 Algorithmes de tris efficaces 113

10.1 Introduction à la stratégie « Diviser pour régner » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
10.2 Tri Fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
10.2.1 La fonction de fusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
10.2.2 Le tri en lui-même . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
10.3 Tri Rapide (QuickSort) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
10.3.1 Fonction de partition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
10.3.2 Le tri en lui-même . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
10.4 Conclusion et comparaison des tris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

11 Validation des entrées et jeux de tests pour un programme 123

11.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
11.2 Validation des entrées. Assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
11.2.1 Assertion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
11.2.2 Type d’un élément . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
11.3 Tests d’un programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
11.3.1 Plusieurs niveaux de tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
11.3.2 Des tests de natures différentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
11.3.3 Un exemple complet : classification de triangles . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

Svartz Page 7/210

TABLE DES MATIÈRES Lycée Masséna

12 Introduction aux graphes 129

12.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
12.2 Vocabulaire des graphes et propriétés mathématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
12.2.1 Graphes non orientés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
12.2.2 Graphes orientés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
12.3 Implémentation des graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
12.3.1 Implémentation « creuse » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
12.3.2 Représentation « dense » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
12.4 Intermède : structure de pile et de file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
12.4.1 Structure de pile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
12.4.2 Structure de file . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
12.4.3 Sous-module deque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
12.5 Parcours de graphes donnés par liste d’adjacence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
12.5.1 Parcours générique de graphe depuis un sommet source . . . . . . . . . . . . . . . . . . . . . . 135
12.5.2 Parcours en largeur et plus courts chemins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
12.5.3 Parcours en profondeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
12.6 Applications du parcours en profondeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
12.6.1 Connexité d’un graphe non orienté . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
12.6.2 Détection de circuit dans un graphe orienté . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
12.6.3 Détection de cycle dans un graphe non orienté . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
12.7 Graphes pondérés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
12.7.1 Pondération . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
12.7.2 Poids d’un chemin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
12.7.3 Quelques propriétés sur les poids des chemins . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
12.7.4 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
12.8 Algorithmes de Dijkstra et A⇤ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
12.8.1 Algorithme de Dijkstra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
12.8.2 Algorithme A⇤ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
12.8.3 Un exemple d’utilisation de A⇤ dans un cadre concret . . . . . . . . . . . . . . . . . . . . . . . 144

V Bases de données 147

13 Requêtes sur une base de données à une table 149
13.1 Introduction : limite des structures de données plates pour la recherche d’informations . . . . . . . . . 149
13.2 Présentation succincte des bases de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
13.2.1 Rôle des bases de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
13.2.2 Un exemple avec quelques requêtes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
13.2.3 Architecture client-serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
13.2.4 Logiciels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
13.2.5 Abstraction des bases de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
13.3 Vocabulaire des bases de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
13.3.1 Modélisation en tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
13.3.2 Vocabulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
13.3.3 Contraintes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
13.3.4 Clés primaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
13.4 Requêtes en SQL sur une seule table : sélection, projection et renommage . . . . . . . . . . . . . . . . 155
13.4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
13.4.2 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
13.4.3 Projection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
13.4.4 Sélection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
13.4.5 Sélection et projection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
13.4.6 Renommage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
13.5 Agrégats et fonctions d’agrégation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
13.5.1 Fonction d’agrégation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
13.5.2 Agrégats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
13.5.3 SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
13.5.4 Sélections et agrégation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
13.5.5 WHERE ou HAVING ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

Svartz Page 8/210

TABLE DES MATIÈRES Lycée Masséna

13.6 Affichage des résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

13.6.1 Ordonner les résultats avec ORDER BY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
13.6.2 Limiter l’affichage avec LIMIT et OFFSET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
13.7 Récapitulatif des requêtes sur une seule table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
13.8 Composition de requêtes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

14 Bases de données à plusieurs tables 163

14.1 Modèle entités-associations, clés étrangères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
14.1.1 Entités et associations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
14.1.2 Cardinalités des associations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
14.1.3 Transformation d’une cardinalité ? • ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
14.1.4 Clés primaires et clés étrangères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
14.2 Produit cartésien et jointure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
14.2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
14.2.2 Produit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
14.2.3 Jointure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
14.3 Tables multiples en SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
14.3.1 Produit cartésien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
14.3.2 Jointure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
14.3.3 Quelques exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
14.3.4 Auto-jointure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
14.3.5 Pour conclure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
14.4 Opérateurs ensemblistes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

VI Compléments d’algorithmique : dictionnaires et programmation dynamique 171

15 Implémentation des dictionnaires 173
15.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
15.2 Adressage direct et limites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
15.2.1 Principe de l’adressage direct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
15.2.2 Limites de l’adressage direct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
15.3 Tables de hachage de largeur fixe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
15.3.1 Fonctions de hachage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
15.3.2 Parenthèse : le hachage en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
15.3.3 Utilisation pour la structure de dictionnaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
15.3.4 Implémentation en Python de la structure de dictionnaire . . . . . . . . . . . . . . . . . . . . . 175
15.3.5 Complexité : discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
15.4 Tables de hachage de largeur variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

16 Programmation dynamique 179

16.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
16.2 Un exemple complet : chemin de poids maximal dans une matrice . . . . . . . . . . . . . . . . . . . . 179
16.2.1 Le problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
16.2.2 Recherche exhaustive ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
16.2.3 Solutions aux sous-problèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
16.2.4 Une relation récursive pour le poids maximal d’un chemin . . . . . . . . . . . . . . . . . . . . . 180
16.2.5 Un calcul itératif des pi,j . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
16.2.6 Détermination d’une solution au problème initial . . . . . . . . . . . . . . . . . . . . . . . . . . 181
16.2.7 Une parenthèse sur une approche gloutonne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
16.3 Principes de la programmation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
16.3.1 La démarche d’une résolution de problème par programmation dynamique . . . . . . . . . . . . 182
16.3.2 Une parenthèse sur les problèmes de combinatoire . . . . . . . . . . . . . . . . . . . . . . . . . 183
16.4 Autres exemples de résolution par programmation dynamique . . . . . . . . . . . . . . . . . . . . . . . 184
16.4.1 Le problème de la plus longue sous séquence commune . . . . . . . . . . . . . . . . . . . . . . . 184
16.4.2 Distance d’édition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
16.4.3 L’algorithme de Floyd-Warshall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187

Svartz Page 9/210

TABLE DES MATIÈRES Lycée Masséna

VII Enjeux contemporains : introduction à l’intelligence artificielle et à la théorie

des jeux 191
17 Apprentissage supervisé ou non 193
17.1 Algorithme des k plus proches voisins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
17.1.1 Un exemple concret . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
17.1.2 Un exemple dans le plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
17.1.3 Matrice de confusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
17.2 Algorithme des k-moyennes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
17.2.1 L’algorithme en pseudo-code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
17.2.2 Analyse de l’algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
17.2.3 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
17.2.4 Une application : compression d’images . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

18 Introduction à la théorie des jeux 201

18.1 Jeu d’accessibilité sur un graphe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
18.1.1 Exemple : un jeu de Nim . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
18.1.2 Vocabulaire : arène, condition de victoire, positions gagnantes et stratégies . . . . . . . . . . . 202
18.1.3 Attracteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
18.1.4 Algorithme de calcul de l’attracteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
18.2 Algorithme Minimax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
18.2.1 Représentation par un arbre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
18.2.2 Stratégie optimale pour un jeu Min-Max . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
18.2.3 Algorithme avec heuristique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
18.2.4 Élagage ↵ (HP) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

Svartz Page 10/210