Option Informatique/cours de l`option informatique

Option informatique MPSI
Lycée Cézanne.
Année 2016-2017

©MPSI–Joly–Lycée Cézanne–2016-2017 2

Table des matières
1 Quelques idées sur le typage 1
1.1 Pourquoi des types ? ................................... 1
1.2 types génériques ..................................... 2
1.3 Les constructeurs des types génériques ......................... 2
1.4 Fonctions à profil générique ............................... 2
2 Introduction à Caml(light) 4
2.1 Premiers pas en Caml .................................. 4
2.2 Quelques types de base en Caml ............................ 6
2.2.1 Type unit .................................... 6
2.2.2 Types int et float ............................... 6
2.2.3 Type bool .................................... 8
2.2.4 Les types char et string ............................ 8
2.2.5 Produits cartésiens ................................ 9
2.2.6 Deux types définis par l’utilisateur ....................... 9
2.3 Les fonctions, premiers pas ............................... 11
2.4 Le filtrage ......................................... 14
2.5 Structures de contrôle .................................. 15
2.5.1 Structure conditionnelle ............................. 16
2.5.2 Boucle for ..................................... 16
2.5.3 Les références ................................... 16
2.5.4 Boucle while ................................... 19
2.6 Filtrage et récursivité .................................. 20
2.6.1 Principe général ................................. 20
2.6.2 Remplacement des boucles ........................... 21
2.6.3 Remplacement des références .......................... 22
2.7 Récursivité terminale ................................... 22
2.8 Tableaux ......................................... 24
2.9 Listes ........................................... 25
3 Structures de données 29
3.1 À propos des structures de données ........................... 29
3.2 Piles ............................................ 30
3.2.1 Spécification ................................... 30
3.2.2 Implémentations ................................. 31
3.2.3 intérêt ....................................... 32
3.2.4 Une application .................................. 33
3.3 Files ............................................ 35
3.3.1 Spécification ................................... 35
3.3.2 Implémentations ................................. 36
3.3.3 Files de priorité .................................. 41
3.4 Dictionnaires ....................................... 42
3.4.1 Spécification ................................... 42
3.4.2 Implémentations ................................. 42
3.5 Arbres ........................................... 42
3.5.1 Aspects informels ................................. 43
3.5.2 Aspects formels .................................. 45
3.5.3 Spécification ................................... 48
3.5.4 Implémentation .................................. 49
i

TABLE DES MATIÈRES TABLE DES MATIÈRES
3.5.5 Quelques exemples de filtrages ......................... 49
3.5.6 Parcours d’arbres binaires ............................ 50
4 Méthodes de programmation 58
4.1 Récursivité ........................................ 58
4.1.1 Un exemple simple ................................ 58
4.1.2 Construction et principe ............................. 58
4.1.3 Terminaison et correction ............................ 60
4.1.4 Terminaison et correction, exemples ...................... 63
4.1.5 Terminaison et correction, exercices d’application ............... 64
4.2 Diviser pour régner .................................... 65
4.2.1 Principe de la méthode ............................. 65
4.2.2 Exemples d’algorithmes diviser pour régner .................. 65
4.3 Programmation dynamique ............................... 68
4.3.1 Principes de la programmation dynamique ................... 68
4.3.2 Ordonnancement de tâches pondérées ..................... 69
4.3.3 Distance d’édition ................................ 72
5 Algorithmes, analyse 83
5.1 Complexité, introduction ................................. 83
5.1.1 Premières idées .................................. 83
5.1.2 Deux exemples .................................. 85
5.1.3 Résultats théoriques ............................... 85
5.2 Complexité, cas des algorithmes diviser pour régner ................. 86
5.2.1 Un petit point technique utile .......................... 86
5.2.2 Retour sur la stratégie .............................. 86
5.2.3 Cas plus général ................................. 87
5.3 Exemples de complexité d’algorithmes diviser pour régner .............. 88
5.3.1 L’algorithme d’exponentiation rapide ...................... 88
5.3.2 L’algorithme de Knuth .............................. 89
5.3.3 L’Algorithme de Strassen ............................ 90
©MPSI–Joly–Lycée Cézanne–2016-2017 ii

Chapitre 1
Quelques idées sur le typage
“Well-typed programs cannot "go wrong" ”
Robert Milner, A Theory of Type Polymorphism in Programming, 1978
La notion de type est essentielle en informatique. De façon simple et imagée, le typage des
données est la première pierre de la construction d’une grammaire qui permet l’interprétation des
codes exprimés dans un langage de haut niveau par la machine elle même (à bas niveau donc).
Il est possible de faire un parallèle avec les mathématiques. On sait qu’un point clef de la
compréhension d’un problème de mathématique consiste à bien comprendre à quels ensembles les
objets présentés appartiennent. Par exemple l’expression u+vne peut être comprise que si on sait
à quels ensembles appartiennent uet v. Si uet vsont deux nombres entiers u+vest un nombre
entier, si uet vsont deux applications de Rdans C,u+vest une application de Rdans C.
Il est intéressant de noter que si u∈Ret v∈CR, l’expression u+vn’a plus de sens!
Exercice 1.0.1
On vient de voir que si uet vn’appartiennent pas au même ensemble, l’expression u+v
n’a pas de sens. Que se passe-t-il si u∈Cet v∈N? Y-a-t-il un moyen de contourner la
difficulté ?
1.1 Pourquoi des types ?
L’attribution d’un type particulier à chaque élément d’une expression en clarifie le sens. De nom-
breux langages de programmation disposent ainsi d’un système de types (dits de base, élémentaires
ou prédéfinis). C’est ce que l’on voit avec Python avec les types : int, float, tuple, list,
bool, function. Par ailleurs, ces mêmes langages disposent aussi de règles de construction de
nouveaux types. Cela permet à l’utilisateur ou au langage lui même de définir un nouveau type.
Dans le cas des langages de programmation typés comme Caml , la définition se fait souvent de fa-
çon automatique. Ces règles de typage permettent d’exprimer quels opérateurs et quelles fonctions
sont applicables à quelles expressions, éliminant ainsi certaines erreurs de programmation. Comme
en mathématiques, si fest une application de Rdans Ret si xest un nombre réel, l’expression
f+xn’a pas de sens.
La notation e:Test usuellement utilisée pour exprimer le fait que l’expression eest de type T.
L’expression e:Test vraie ou fausse, ce n’est pas une déclaration (comme dans certains langages
comme Cou C++). Une interprétation simple de e:Tconsiste à considérer un type comme un
ensemble (parfois infini) de données de même nature. On peut interpréter e:Tpar eappartient à
T, ce qui signifie que toutes les valeurs possibles de l’expression eappartiennent à l’ensemble T.
Si on distingue le symbole “:” du symbole “∈” en théorie des types abstraits, c’est pour pouvoir
donner un type au symbole “∈” en écrivant ∈:T. On remarque que c’est cette notation qui a été
retenue pour la signature (on dit encore le profil) des applications. Lorsqu’on écrit f:E→Fon
exprime le fait que fappartient à l’ensemble des applications de l’ensemble Edans l’ensemble F.
1