VUIBERT

N. Carré • R. Mansuy

OPTIONINFORMATIQUE

MPSI • MP/MP*

VUIBERT

SOMMAIRE :

Partie I : Bases de la programmation 1. Prise en main de Caml – 2. Fonctions – 3. Structures de données – 4. Listes – 5. Tableaux 6. Arbres – 7. Analyse d’algorithmes Partie II : Programmation avancée 8. Programmation dynamique – 9. Diviser pour régner – 10. Arbres binaires – 11. Graphes

Partie III : Langages, automates12. Mots, langages, motifs – 13. Automates – 14. Langages rationnels

Partie IV : Logique15. Expressions logiques – 16. Satisfiabilité

Tous les chapitres comportent différents types d’exercices corrigés.À la fin de chaque partie, on trouvera des problèmes type concours.En annexe le programme d’option informatique en MPSI et MP/MP*.

LES AUTEURS :Nathaniel Carré est professeur en CPGE au lycée Louis-le-Grand à Paris.Roger Mansuy est professeur en CPGE au lycée Saint-Louis à Paris.

ISBN : 978-2-311-40683-2

, la collection idéale pour assurer sa réussite en CPGE scientifiques.Ce manuel Tout-en-un propose :- un cours de référence, conforme au programme, illustré d’exemples et de démonstrations ;

- de nombreux encarts pour mieux se repérer ;- des conseils méthodologiques pour éviter les erreurs ;- des fiches « Mémento » pour retenir l’essentiel et réviser ;- plus de 180 exercices, problèmes et sujets de concours pour s’entraîner ;- tous les corrigés détaillés et commentés.

MPSIMP

MP*OPTION INFORMATIQUE MPSI • MP/MP*

OPTI

ON IN

FORM

ATIQ

UE

Tout-en-unÀ jour du passage en langage OCaml Tout le cours Conseils méthodologiques Fiches Mémento Vrai/faux Exercices d’application Exercices d’approfondissement Problèmes type concours Tous les corrigés détaillés

2e ÉDITION ACTUALISÉE

2e ÉDITION ACTUALISÉE

VUIBERT

2e édition actualisée

Nathaniel Carré est professeur en CPGE au lycée Louis-le-Grand à Paris.

Roger Mansuy est professeur en CPGE au lycée Saint-Louis à Paris.

OPTION INFORMATIQUE

MPSI•MP/MP*

9782311013016_001-002.indd 1 03/12/2018 15:36

Maquette et mise en page : Sébastien Mengin/EdilibreCouverture et liminaires : Les PAOistes et E. Linares

ISBN : 978-2-311-40683-2

La loi du 11 mars 1957 n’autorisant aux termes des alinéas 2 et 3 de l’article 41, d’une part, que les « copies ou reproductions strictement réservées à l’usage privé du copiste et non destinées à une utilisation collective » et, d’autre part, que les analyses et les courtes citations dans un but d’exemple et d’illustration, « toute représentation ou reproduction intégrale, ou partielle, faite sans le consentement de l’auteur ou de ses ayants droit ou ayants cause, est illicite » (alinéa 1er de l’article 40). Cette représentation ou reproduction, par quelque procédé que ce soit, constituerait donc une contrefaçon sanctionnée par les articles 425 et suivants du Code pénal. Des photocopies payantes peuvent être réalisées avec l’accord de l’éditeur. S’adresser au Centre français d’exploitation du droit de copie : 20 rue des Grands Augustins, F-75006 Paris. Tél. : 01 44 07 47 70

© Vuibert – janvier 2019 – 5 allée de la 2e DB, 75015 Paris

Dans la même collection :

Tout-en-un :MATHÉMATIQUES MPSI, R. MansuyMATHÉMATIQUES MP/MP*, X. Oudot, H. Cerf Danon & V. Lods INFORMATIQUE POUR TOUS - 1re ET 2e ANNÉES, A. Caignot, M. Dérumaux, L. Moisan & J. LabasquePHYSIQUE MPSI-PCSI-PTSI, M. Cavelier, J. Cubizolles, G. Delannoy, E. Jahier & C. JorssenPHYSIQUE-CHIMIE MP/MP*, F. Bruneau, M. Cavelier, E. Jahier, C. Jorssen, Y. Lozier, M. Marchand-Hartog & Ph. RibièreCHIMIE MPSI-PTSI, L. Almeras, J. Appenzeller, C. Giroud & C. Vilain SCIENCES INDUSTRIELLES DE L’INGÉNIEUR MPSI-PCSI-PTSI, A. Caignot, V. Crespel, M. Dérumaux, C. Garreau, P. Kaszinski, B. Martin & S. RouxSCIENCES INDUSTRIELLES DE L’INGÉNIEUR MP/MP*-PSI/PSI*-PT/PT*, A. Caignot, V. Crespel, M. Dérumaux, C. Garreau, B. Martin, A. Redondo, S. Roux

Pour s’entraîner :MATHÉMATIQUES MPSI, A. Bechata & N. de GranrutMATHÉMATIQUES MP/MP*, D. Caffin, M. Lichtenberg & X. OudotSCIENCES INDUSTRIELLES DE L’INGÉNIEUR MPSI-PCSI-PTSI, A. Caignot, F. Golanski, F. Hospital, D. Iceta, X. Pessoles & D. VioleauSCIENCES INDUSTRIELLES DE L’INGÉNIEUR MP/MP*-PSI/PSI*-PT/PT*, V. Boyer, A. Caignot, F. Golanski, D. Iceta, X. Pessoles & D. VioleauCHIMIE MPSI-PTSI, J. Appenzeller, A. Morland & C. Vilain

Retrouvez des dizaines d’autres livres de référence, d’étude ou de culture en mathématiques, informatique et autres spécialités scientifiques sur

www.vuibert.fr

9782311013016_001-002.indd 2 03/12/2018 15:36

Table des matières

Chapitre 0. Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41. Algorithmes 5 – 2. Paradigmes de programmation 6 – 3. Mémoire et pointeurs 7

I. Bases de la programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

Chapitre 1. Prise en main de Caml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101. Démarrage 11 – 2. Types élémentaires 12 – 3. Structure conditionnelle 16 – 4. Éléments deprogrammation impérative 18 – Mémento 20 – Exercices 21 – Corrigés 22

Chapitre 2. Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261. Types fonctionnels 27 – 2. Filtrage 29 – 3. Récursivité 32 – 4. Exceptions 33 – Mémento 36 –Exercices 37 – Corrigés 40

Chapitre 3. Structures de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481. Type de données abstrait 49 – 2. Types personnalisés 53 – Mémento 56 – Exercices 57 – Corri-gés 58

Chapitre 4. Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601. Listes chaînées 61 – 2. Module List 61 – 3. Piles 67 – 4. Files 68 – Mémento 70 – Exercices 71 –Corrigés 75

Chapitre 5. Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 821. Présentation des tableaux 83 – 2. Opérations sur les tableaux 86 – 3. Files de taille bornée 88 –4. Tables de hachage 89 – Mémento 91 – Exercices 92 – Corrigés 94

Chapitre 6. Arbres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1001. Généralités 101 – 2. Fonctions élémentaires sur les arbres 104 – 3. Parcours d’arbres binaires 107– Mémento 112 – Exercices 113 – Corrigés 117

Chapitre 7. Analyse d’algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1221. Terminaison 123 – 2. Correction 129 – 3. Complexité 130 – Mémento 137 – Exercices 138 –Corrigés 140

Problèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146Enveloppe convexe 146 – Codage de Huffman 147 – Corrigés 150

II. Programmation avancée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

Chapitre 8. Programmation dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1561. Programmation dynamique 157 – 2. Memoïsation 164 – Mémento 166 – Exercices 167 – Corri-gés 168

III

Table des matières

Chapitre 9. Diviser pour régner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1741. Présentation de la méthode 175 – 2. Plus proches voisins dans un nuage de points 178 – 3. Algo-rithmes de tri 180 – Mémento 189 – Exercices 190 – Corrigés 192

Chapitre 10. Arbres binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2001. Arbres binaires de recherche 201 – 2. Tas 206 – Mémento 213 – Exercices 214 – Corrigés 216

Chapitre 11. Graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2221. Définitions et exemples 223 – 2. Parcours d’un graphe 229 – 3. Graphes pondérés et plus courtschemins 234 – Mémento 240 – Exercices 241 – Corrigés 243

Problèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251Transformée de Fourier rapide 251 – Arbres gauchers 252 – Problème du voyageur de commerce 254– Corrigés 257

III. Langages, automates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265

Chapitre 12. Mots, langages, motifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2661. Mots 267 – 2. Langages 270 – 3. Motifs 271 – Mémento 276 – Exercices 277 – Corrigés 279

Chapitre 13. Automates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2861. Calculs sur un automate 287 – 2. Simplification des automates 290 – 3. Automates non détermi-nistes 294 – 4. Déterminisation 295 – Mémento 299 – Exercices 300 – Corrigés 302

Chapitre 14. Langages rationnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3101. Construction des langages rationnels 311 – 2. Langages locaux 314 – 3. Théorème de Kleene 316– 4. Propriétés des langages rationnels 320 – Mémento 326 – Exercices 327 – Corrigés 329

Problèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336Mots de Dyck 336 – Longueur discriminante 337 – Corrigés 339

IV. Logique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345

Chapitre 15. Expressions logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3461. Syntaxe 347 – 2. Sémantique 348 – 3. Implémentation 353 – Mémento 354 – Exercices 355 –Corrigés 358

Chapitre 16. Satisfiabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3641. Formes normales conjonctives ou disjonctives 365 – 2. Tautologies et satisfiabilité 368 – Mé-mento 371 – Exercices 372 – Corrigés 373

Problèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3772-SAT et 3-SAT 377 – Corrigés 380

Annexe Programme d’option informatique en MPSI et MP . . . . . . . . . . . . . . . . . . . . . . 384

IV

Avant-propos

Le programme d’option informatique en MPSI/MP présente l’ambition d’apporter aux étudiantsdes connaissances transverses en informatique théorique, au même titre que des compétences deprogrammation variées.

. Découvrir un langage de programmation fonctionnel (ici CAML) en gardant à l’esprit que « lavirtuosité dans l’écriture de programmes ou une connaissance exhaustive des bibliothèques de pro-grammation ne sont pas des objectifs de la formation. ».

. Comprendre les concepts théoriques de structures abstraites de données et savoir les implémenterdans un langage de programmation.

. Acquérir les techniques de programmation avancées et savoir exhiber leurs performances.

.Modéliser un problème concret, choisir une structure adaptée, écrire un programme et l’évaluer.

Choix de la rédactionAprès un court chapitre d’introduction à l’informatique, la deuxième édition de ce livre est séparéeen quatre parties :

• Bases de la programmation : on y découvre le langage CAML, ses types et structures élémentaires,ainsi que l’étude de la performance des algorithmes.

• Programmation avancée : des techniques de programmation sont étudiées en détails, ainsique des structures abstraites avancées et leurs implémentations.

• Langages, automates : on étudie des problèmes de recherche de motifs dans un texte ainsi quela théorie des langages rationnels.

• Logique : on expose ici les bases de la logique du premier ordre en étudiant les formules sansquantificateurs.

Les changements par rapport à la première édition sont :

• la réorganisation des chapitres pour identifier clairement les notions de MPSI (chapitres 1 à 9)et de MP (chapitres 10 à 16) ;

• la réécriture de tous les programmes informatiques, due notamment au changement de langagede programmation mis en œuvre en 2018 (passage de CAML-LIGHT, non maintenu depuis 2002et utilisé uniquement pour l’enseignement en classes préparatoires, à OCAML) ;

• la présence de conseils méthodologiques et d’un index récapitulant les différentes commandesCAML ;

• la description des objectifs en début de chaque chapitre ;• la découverte de l’histoire de l’informatique par de multiples biographies ;• l’ajout de problèmes type écrits de concours en fin de chaque partie, pour mettre en œuvre les

compétences acquises ;• l’ajout et modification de nombreux exercices, séparés en exercices d’application et exercices

d’approfondissement ;• la correction d’erreurs et fautes typographiques ;• une annexe contenant le programme officiel de l’option informatique.

1

RemerciementsLa première édition de cet ouvrage est née du désir de fournir au plus grand nombre d’étudiants unoutil complet pour réussir les épreuves d’option informatique. Malgré les efforts et avis de nombreuxrelecteurs (qu’ils soient à nouveau remerciés), le volume publié restait perfectible. L’éditeur a sou-haité proposer une édition corrigée et adaptée au changement de langage informatique pour cetteoption (passage de CAML à OCAML). Il me semblait important de profiter de cette opportunité pourchanger certains aspects de la présentation générale et compléter l’ensemble. Cela ne pouvait se fairequ’avec le regard neuf et les compétences d’un collègue. Je suis très heureux, et fier, que NathanielCarré ait accepté cet immense travail d’auteur en marge de son (excellent mais prenant) travail aulycée Louis-le-Grand : ses idées, son expérience et sa patience ont permis de faire du volume quevous tenez entre les mains bien plus qu’une deuxième édition ! Je lui suis très reconnaissant de toutce temps sacrifié pour reprendre ce projet.

Roger Mansuy

Je tiens dans un premier temps à remercier Roger Mansuy de m’avoir proposé de participer à ceprojet. Je remercie également les anciens membres du Binet Réseau de l’École polytechnique qui ontsupporté et enrichi mes débats et questionnements sur de nombreux sujets d’informatique au coursde la rédaction de ce livre. Comme mon co-auteur, j’affirme que ce livre n’existerait pas (ou seraitde bien moins bonne qualité) sans la participation de mes nombreux relecteurs qui ont su détecterdes anomalies de rédaction ou des erreurs de code comme de raisonnement; s’il reste des erreursdans ce livre, c’est bien évidemment leur ma faute. En particulier, pour la relecture de chapitres, jeremercie Xavier Bonnetain, Matthias Bry, Jeremy Buet, Simon Cruanès, Arthur Darcet, GuillaumeDidier, Alexis Gérard et Thibaud Victoire-Mendoza. Pour la relecture de problèmes, je remercie deplus Tristan Brugère, Nataniel Marquis et Paul Wang, ainsi que Guillaume Dewaele qui, en plus dem’avoir fourni des conseils pour ce livre, me supporte au quotidien en tant que collègue.

Nathaniel Carré

Préface

Une élève de classe préparatoire, qu’une faille spatio-temporelle conduirait au début du MoyenÂge, découvrirait un enseignement des sciences très différent de celui qu’elle connaît. Pas de phy-sique, de chimie, de géologie, de biologie. . . , ces sciences n’avaient pas encore été inventées. Pasd’enseignement des techniques non plus, les sciences et les techniques appartenaient alors à desordres différents. Les écoles, à cette époque, n’enseignaient que quatre sciences : l’arithmétique, lamusique, la géométrie et l’astronomie.

L’enseignement des sciences et des techniques a donc bien changé. Il s’est, en fait, transformé toutau long de son histoire, car l’histoire des sciences et des techniques, elle-même, est une révolutionpermanente.

Pour faire évoluer leurs enseignements sur une grande échelle, les enseignants disposent cependantde peu de moyens. Il y a, bien entendu, les programmes, longuement discutés, avant d’être déployéssur de grands territoires. Mais un programme contient une quantité d’information trop faible pourêtre efficace à lui seul. L’outil le plus efficace, pour impulser une transformation des enseignements,est, en fait, un bon manuel. Les manuels, les polycopiés, les notes de cours. . . sont le réel fermentde la transformation de l’école et de l’université. Ils sont aussi, parce qu’ils articulent un vasteensemble de connaissances, un élément essentiel de la structuration des sciences elles-mêmes. C’estpour cela que, quand notre pays entreprend enfin d’introduire un enseignement de l’informatiquede la maternelle au doctorat, l’écriture de bons manuels constitue un enjeu majeur. Les classespréparatoires occupant une place particulière dans le graphe de nos enseignements – c’est un lieuoù se croisent, avant de se disperser, un nombre important de personnes qui auront, plus tard,la possibilité, et la responsabilité, de transformer l’industrie, l’université, l’administration. . . – lesmanuels des classes préparatoires constituent un enjeu doublement décisif.

Mais écrire un bon manuel d’informatique est une tâche difficile, car il faut faire tenir, en quelquescentaines de pages, des connaissances très diverses, de l’organisation de la mémoire d’un ordinateuraux algorithmes de décision pour la logique propositionnelle. Il faut surtout, comme dans les potionsdes sorcières, doser chaque ingrédient avec une grande précision. Veiller à l’équilibre entre les diffé-rentes notions de l’informatique. À celui entre ses aspects scientifiques et techniques : expliquer, parexemple, que la concaténation de deux langages rationnels est rationnelle (Proposition 14.25), maisaussi comment écrire un programme. Il faut parvenir à intéresser autant les futurs informaticiens, quis’orientent naturellement vers les concepts fondamentaux de la discipline, que les futurs chimistes,qui se demandent plutôt ce que l’informatique apporte à leur propre pratique. Il faut faire une placeà l’histoire, car ces connaissances ne sont pas tombées du ciel, mais elles répondent à des questionsque des femmes et des hommes se sont posées, à un moment particulier du développement desconnaissances. Et surtout, il faut aider les élèves à s’approprier ces connaissances, par des exerciceset des réalisations pratiques, afin que, eux aussi aient envie, quelques années plus tard, d’écrire leurmanuel et de poursuivre le travail commencé.

Réussir tout cela à la fois tient de l’exploit. C’est cet exploit que vous tenez dans les mains. Je voussouhaite une bonne lecture et, surtout, faites les exercices.

Gilles Dowek,

chercheur à Inria,

professeur à l’École normale supérieure de Paris-Saclay.

3

Chapitre 0

Généralités1. Algorithmes – 2. Paradigmes de programmation – 3. Mémoireet pointeurs

Objectifs et compétences du programme• Découvrir le vocabulaire général de l’informatique.• Comprendre les différentes façons d’écrire un algorithme.• Appréhender la gestion informatique de la mémoire.

Histoire des sciences

Muhammad Ibn Musa al-Khuwarizmi est né dans les années 780dans l’actuel Ouzbékistan et décédé dans les années 850 à Bagdad.Scientifique éminent, historien, géographe, astrologue et astronome,Al-Khwarizmi (comme on l’appelle plus couramment) est notammentconnu pour ses travaux en mathématiques.Durant sa vie, il a classifié les algorithmes et étudié leur terminaison. Ila également rédigé un traité sur un algorithme de résolution des équa-tions du second degré dans le cas général, par la restauration (al-jabr,qui a donné son nom à l’algèbre) et la comparaison (al-muqabala).Al-Khwarizmi est aussi celui qui a répandu l’utilisation du zéro et deschiffres arabes en Orient et en Occident, chiffres originaires d’Inde

(contrairement à ce que leur nom indique) et étudiés notamment par Brahmagupta auVIIe siècle.Outre l’algèbre, Al-Khwarizmi a donné son nom latinisé, Algoritmi, à ce que nous connaissonsaujourd’hui comme les algorithmes.

4

Chapitre 0 – Généralités

COUR

S1. Algorithmes1.1. Définition

Définition 0.1.

Un algorithme est une suite finie d’instructions non ambigües correspondant à la résolution d’unproblème dont les entrées et les sorties sont précisées.

Exemple

Il existe des algorithmes de résolution du Rubik’s cube ; l’entrée est une configuration (mélan-gée) du cube et la sortie est la liste des mouvements permettant de passer de cette configura-tion initiale à la configuration rangée. Quelle que soit la configuration initiale, l’algorithmefournira la solution pour la résolution.

Définition 0.2.

Une fonction (informatique) est une portion de programme qui exécute un algorithme. Elle peutêtre utilisée avec différents arguments et renvoyer des résultats dépendant de ses arguments.

De manière générale, voici le cheminement d’une résolution informatique :

1. Concevoir l’algorithme c’est-à-dire déterminer les instructions qui le composent.2. Choisir la structure de données idoine (pour les entrées, les variables utilisées ou les sorties).3. Analyser l’algorithme c’est-à-dire justifier sa terminaison (l’algorithme s’arrête-t-il ?), sa correc-

tion (renvoie-t-il le résultat espéré ?) et sa complexité (utilise-t-il des ressources raisonnablesen mémoire et en temps ? combien effectue-t-il de comparaisons ? d’affectations ? d’opérationsarithmétiques ?).

4. Le programmer dans un langage de programmation.

Il semble assez naturel de prendre les deux premières décisions simultanément (l’algorithme dépenddes opérations autorisées par la structure de données choisie) ; souvent, le choix du langage de pro-grammation est aussi fortement lié à l’algorithme utilisé. Toutefois, il est important de comprendrequ’en première approximation, la conception d’un algorithme et son implémentation pratique dansun langage sont des activités indépendantes qui font appel à des compétences différentes.

1.2. ExemplesNous étudierons des algorithmes tout au long de ce cours. Voici deux exemples pour comprendre leprincipe général.

5

Option informatique MPSI/MP-MP*

Exemple

Intéressons-nous au problème pratique de la recherche d’un mot dans un dictionnaire defrançais. L’entrée est composée d’un mot et d’un dictionnaire et la sortie est la définition dumot. Voici deux algorithmes répondant à cette question.. Algorithme 1.

1. Ouvrir le dictionnaire à la première page.2. Tant que le mot recherché n’est pas dans la page, tourner la page.3. Lire la définition.

Cet algorithme permet de trouver la solution mais on sent bien (il faudra le quantifier) quele temps qu’il faudra pour trouver la définition de « syzygie » risque d’être plutôt long. C’estsûrement pour cela que ce n’est pas l’algorithme couramment utilisé. Il serait le seul adaptési on n’avait pas la possibilité d’ouvrir une page au milieu du dictionnaire.. Algorithme 2.

1. Ouvrir le dictionnaire au milieu.2. (a) Si le mot est dans la page, lire la définition.

(b) Si le mot est après le dernier mot de la page, chercher le mot dans le dictionnaireconstitué de la moitié droite du dictionnaire.

(c) Sinon, chercher le mot dans le dictionnaire constitué de la moitié gauche dudictionnaire.

Pour pouvoir appliquer cet algorithme, il convient de pouvoir accéder au milieu du diction-naire. Cette version est souvent celle appliquée (plus ou moins) en pratique.

2. Paradigmes de programmationUn paradigme est une manière de penser et de représenter le monde. Les paradigmes de program-mation sont les différentes philosophies de méthodes et de rédaction de code qui sont utilisables parle programmeur pour résoudre un problème informatique. Sans être complètement incompatibles,ils sont plus ou moins développés selon les langages de programmation.

2.1. Fonctionnel contre ImpératifCAML est un langage principalement fonctionnel. En programmation fonctionnelle, on considère lecalcul comme l’évaluation successive de fonctions sans modifier l’état de la mémoire. Une fois créé,un objet ne peut pas être modifié.

Ce paradigme est en opposition à la programmation impérative qui consiste à modifier la mémoirelors de l’exécution des calculs. Les objets informatiques y sont alors modifiables. Bien qu’étantfonctionnel, CAML dispose également d’éléments de programmation impérative.

2.2. Récursif contre ItératifRécursif : de recurrere, « courir en arrière ». Itératif : de iterare, « recommencer, répéter ».

Une fonction récursive est une fonction qui s’appelle elle-même. Une fonction itérative est unefonction qui répète des instructions qui modifient l’état de la mémoire un certain nombre de fois(connu à l’avance ou non). Ainsi, en prenant comme référence la définition des paradigmes fonc-tionnels et impératifs, on associera la récursivité à la programmation fonctionnelle et l’itérativité à laprogrammation impérative.

6

Chapitre 0 – Généralités

COUR

S3. Mémoire et pointeursPour comprendre le déroulé de l’exécution d’un programme, il peut souvent être nécessaire decomprendre le fonctionnement de la gestion de la mémoire informatique. Des erreurs courantespeuvent notamment être évitées en comprenant la notion de pointeur.Lorsque, dans un programme, on dit qu’une variable contient un réel, un tableau, une liste, unematrice, ..., la réalité en est autre : une variable ne contient systématiquement qu’un pointeur. Qu’est-ce qu’un pointeur? Un entier qui indique à quelle adresse mémoire les informations doivent êtrelues lors de l’exécution du programme.Pour un objet simple, la case mémoire indiquée va contenir un autre entier. Dans des cas trèsparticuliers, c’est le pointeur lui-même qui contient l’information (par exemple pour les entiersen CAML). Pour les objets informatiques plus complexes, la case mémoire pointée est une entêtequi contient des métadonnées (type de l’objet, taille des emplacements consécutifs de la mémoireutilisés, ...), et les cases adjacentes contiennent les données (ou des pointeurs vers les données).Schématiquement, on trace une flèche (c’est le pointeur) entre la variable et la case mémoire. Celaressemble à ce qui suit, avec une variable x contenant le réel (ou flottant) 3.7 dans le premier cas etune variable q qui contient le quadruplet (0, ’a’, 1.2, true) dans le second.

x

3.7

q

entête • • • •

0’a’

1.2

true

Cette représentation permet de mieux comprendre les résultats de certaines opérations, par exemplela création d’une variable y par l’instruction y = x ou la tentative d’inversion des valeurs de deuxvariables x = 3.7 et y = 2.3 par les instructions y = x puis x = y.

x

3.7

y

y = x

x

3.7

y

2.3

y = x puis x = y

Retenons qu’en CAML, l’affectation classique se manifeste par la création d’un pointeur vers unecase mémoire. Une fois affectées, les cases mémoires ne sont pas modifiables sauf dans le cas de laprogrammation impérative qui sera étudiée dans le chapitre suivant.

La récupération des emplacements mémoire non utilisés est faite par le Garbage Collector (on trouveles noms français de ramasse-miettes ou glaneur de cellules...), un algorithme qui, à intervallesréguliers, s’occupe d’identifier les cases mémoires non pointées puis repartitionne la mémoireutilisée pour en libérer une partie. Son fonctionnement ne sera pas étudié en détail.

7

Partie 1

BASES DE LAPROGRAMMATION

Chapitre 1

Prise en main de Caml1. Démarrage – 2. Types élémentaires – 3. Structureconditionnelle – 4. Éléments de programmation impérative

Objectifs et compétences du programme• Découvrir le langage Caml.• Manipuler les objets de différents types.• Étudier les structures de contrôles en programmation.

Histoire des sciences

Ada Lovelace (née Byron) est née à Londres en 1815 d’une mère pas-sionnée par les mathématiques. Cette dernière offrit à sa fille uneformation poussée en mathématiques et en sciences, éducation inha-bituelle pour une jeune fille de l’époque. Elle rencontre à 17 ans l’inven-teur Charles Babbage, concepteur de machines à calculer qui fascinentinstantanément la jeune Ada.Malgré un intérêt certain, la vie scientifique d’Ada prend pause pourlaisser place à la vie de famille. Devenue comtesse de Lovelace et mèrede trois enfants, elle reprend contact avec Babbage en 1839, et obtientd’Auguste De Morgan, logicien renommé, qu’il assure son tutorat. Élèvebrillante, elle choisit de se concentrer sur les mathématiques et de tra-

vailler pour Babbage, qui développe la machine analytique, une machine à calculer utilisantdes cartes perforées, sur le modèle des métiers à tisser Jacquard.Outre des travaux de traduction ou de publication, Ada Lovelace devient ainsi la premièrepersonne de l’histoire à écrire un programme informatique, celui du calcul des nombres deBernoulli. Elle a également une vision de calculateur universel, dont une formalisation dûtattendre 1930 avec la machine de Turing.Pour subventionner les travaux de Babbage, Lovelace se lance dans des paris sportifs. Aban-donnée de son mari, criblée de dettes, elle décède auprès de sa mère à l’âge de 36 ans d’uncancer de l’utérus.

10

Chapitre 1 – Prise en main de Caml

COUR

S1. DémarrageCommençons par exécuter une commande simple. Les résultats sont affichés avec un léger surli-gnage.

1 + 4;; (* eh oui, on commence par un calcul difficile *)int = 5

Effectuons quelques remarques techniques : ici on n’a pas représenté le prompt # qui indique la lignetapée par l’utilisateur. La commande d’exécution est ;;. Par ailleurs, les commentaires (c’est-à-direle texte non évalué) sont encadrés par (* *).Pour le résultat, CAML affiche la nature (le type) avant la valeur : ici, il indique int (pour entier ouinteger en anglais) avant de calculer le résultat 5. En CAML, on détermine le type d’un objet avantde l’évaluer. Il est important de réaliser que la compréhension du type par CAML est essentielle etqu’elle précède toujours la partie calculatoire : CAML est un langage fortement typé.

Conseil méthodologiqueSi elle était obligatoire en CAML-LIGHT, la commande d’exécution ;; est facultative en OCAML.Toutefois, elle permet de séparer les blocs de code à exécuter dans plusieurs IDE (environnementde développement), et nous l’écrirons systématiquement dans ce livre.

L’instruction d’affectation est let nomvariable = valeur;; (le mot affectation est ici un tantinetimpropre ; il s’agit plutôt d’une liaison entre un identificateur, le nom, et une valeur). Ici, nous avonscréé une variable de type int dans laquelle nous avons placé la valeur 3.

Attention !

Le nom d’une variable doit toujours commencer par une minuscule.

let x = 3;;val x : int = 3

x + 2;;int = 5

Une fois affectées, les variables ne changent plus : elles ont été totalement évaluées.

let a = 1;;val a : int = 1

let b = a + 1;;val b : int = 2

let a = 2;;val a : int = 2

b;;int = 2

11

Option informatique MPSI/MP-MP*

La même syntaxe sert à l’affectation locale, en rajoutant le mot-clé in (ci-dessous, la variable cn’existe pas en dehors du bloc [terminé par ;;] où elle est définie). Remarquons qu’une erreur estsignalée et commentée.

let c = 2 in c + 2;;int = 4

c;;Characters 0-1:

c;;

^Error: Unbound value c

Il est possible d’effectuer plusieurs affectations simultanément avec le mot-clé and. Lors d’uneaffectation simultanée, les variables en cours de définition n’existent pas encore, même pour le restede l’instruction.

let a = 1 and b = 2;;val a : int = 1val b : int = 2

let c = 1 and d = c + 2;;Characters 19-20:

let c = 1 and d = c + 2;;

^Error: Unbound value c

2. Types élémentaires2.1. DéfinitionEn informatique (que cela soit en théorie ou en programmation), on classe les données par « type ».Cette classification en types permet de regrouper les données en fonction de :

• la syntaxe des manipulations possibles les concernant ;• leur représentation en mémoire.

Regardons des modèles pour les types de nombres.

Exemple

Par exemple, pour définir un type entier, on peut s’appuyer sur une représentation binairesur 32 bits où :

• le premier bit correspond au signe : 1 pour les négatifs, 0 pour les positifs ;• les 31 autres bits correspondent à l’écriture binaire de la valeur absolue.

Pour définir le type flottant (c’est-à-dire un réel d’écriture binaire finie), on peut s’appuyersur une représentation binaire sur 64 bits où :

12

Chapitre 1 – Prise en main de Caml

COUR

S

• le premier bit correspond au signe : 1 pour les négatifs, 0 pour les positifs ;• les 52 bits suivants correspondent à l’écriture binaire de la (troncature de la) mantisse ;• les 11 derniers bits servent pour l’écriture binaire de l’exposant de la puissance de 2

par laquelle il faut multiplier pour avoir le réel.

Outre ces types simples pour représenter une valeur, il existe également des types plus complexes,notamment des structures pour stocker des données.

Dressons une courte liste des types les plus utilisés par CAML. Cette liste est loin d’être exhaustive(elle ne comporte en particulier pas les types structurés comme les listes et les tableaux qui serontétudiés en détail dans les prochains chapitres).

Lorsque l’on programme, il est essentiel de vérifier le typage de chaque expression.

2.2. UnitLe type le plus simple de CAML est le type unit qui ne comporte qu’une valeur () (appelée void).

();;unit = ()

print_newline ();;unit = ()

Il correspond au null ou none dans d’autres langages, et même si son utilité n’est pas évidentepour le débutant, ce type est essentiel pour les fonctions qui ne prennent pas d’argument ou quine renvoient rien.

2.3. Int et FloatIl existe principalement deux types de nombres int et float (qui correspondent respectivementaux entiers et aux réels en machine). Pour bien comprendre les différences entre ces types, on seréfèrera à la façon dont ces valeurs sont stockées informatiquement.

Attention !

Les deux types ne sont pas compatibles et les opérations propres à l’un ne fonctionnent pasavec l’autre.

2;;int = 2

2.;;float = 2.0

13

Option informatique MPSI/MP-MP*

2 + 2.0;;Characters 3-5:

2+2.;;

^^Error: This expression has type float

but an expression was expected of type int

En conséquence, on n’utilise pas les mêmes fonctions pour ces deux types. Pour les opérationsarithmétiques, on distingue les versions +, - et * pour le type int des versions pointées +., -., *.et /. pour le type float.

Les fonctions / et mod sont définies sur des arguments de type int et associent respectivement lequotient et le reste de la division euclidienne. Notons que ces fonctions se placent en position infixe(c’est-à-dire entre les arguments). On leur donne alors le nom d’opérateur.

La plupart des fonctions usuelles sont définies sur le type float.

1789 / 30;; 1789 mod 30;;int = 59int = 19

1789. /. 30.;;float = 59.6333333333

exp 2;;Characters 6-7:

exp 2;;

^Error: This expression has type int

but an expression was expected of type float

Les fonctions sqrt cos sin tan acos asin atan log exp et ** pour l’exponentiation utilisentaussi le type float.

Attention !

log est le logarithme néperien noté ln en mathématiques.

Les fonctions min, max et les opérateurs de comparaison <, = et > fonctionnent pour ces deux types(entre autres).

Il s’avère que les entiers de CAML sont bornés par 262 (230 sur un système 32 bits) : pour obtenir lecodage sur 63 bits (dont un bit pour le signe), CAML effectue donc le calcul modulo 263 en représentantchaque entier par le reste de sa division par 263 dans [[−262, 262−1]]. Cette limite peut entraîner desrésultats surprenants (voire ahurissants) comme :

14

Chapitre 1 – Prise en main de Caml

COUR

S

9*9*9*9*9*9*9*9*9*9*9*9*9*9*9*9*9*9*9*9*9;;int = -1261475310744950487

2147483648 * 2147483648;;int = -4611686018427387904

2147483648 * 2147483648 - 1;;int = 4611686018427387903

max_int;;min_int;;int = 4611686018427387903int = -4611686018427387904

Ces dernières commandes permettent d’accéder aux valeurs extrêmes de l’intervalle des entiers.

Mentionnons qu’il existe des fonctions permettant de convertir un argument d’un type vers un autre(int_of_float et float_of_int) mais elles ne doivent être utilisées qu’en cas d’absolue nécessité.On évitera par exemple l’instruction extrêmement lourde suivante pour calculer x y , où x et y sontdes entiers (l’alternative valide sera étudiée plus tard en exercice) :

int_of_float ((float_of_int x) ** (float_of_int y));;

Enfin, on a parfois besoin d’afficher des valeurs. Pour cela on dispose des fonctions print_int etprint_float qui renvoient un type unit.

print_int 3;;3- : unit = ()

let a = 2.3 in print_float a;;2.3- : unit = ()

2.4. BoolLe type booléen bool comporte deux valeurs true (vrai) et false (faux). Les opérations logiquessont && pour la conjonction (et), || pour la disjonction (ou) et not pour la négation.

Conseil méthodologiqueCAML évalue les expressions booléennes de gauche à droite donc n’évalue pas les arguments sicela n’est pas logiquement nécessaire. Par exemple, CAML ne détecte pas ici l’erreur issue de ladivision par 0 car le premier terme suffit à calculer le résultat.

1 > 0 || 1 / 0 > 0;;bool = true

1 = 0 && 1 / 0 <> 1;;bool = false

15

Option informatique MPSI/MP-MP*

Attention !

Il existe des alias pour la conjonction et la disjonction logiques qui sont respectivement &et or. Pour des raisons évidentes de cohérence, ces alias sont à éviter, notamment pour nepas prendre l’habitude d’utiliser le faux-ami and qui, rappelons-le, ne sert qu’à effectuer uneaffectation simultanée, ou le faux-ami | qui ne sert qu’à effectuer du filtrage ou écrire destypes sommes.

2.5. Produits cartésiensLes produits cartésiens permettent de rassembler des objets de types différents (ce qui ne sera paspossible avec d’autres types composés). On les définit avec des parenthèses (souvent facultatives) etdes virgules comme séparateurs. Dans sa déclaration de type, CAML les note avec le symbole *.

(14, 7, 1789);;int * int * int = 14, 7, 1789

14, 7., 1789;;int * float * int = 14, 7.0, 1789

Pour les couples (et uniquement les couples), on peut récupérer chacune des coordonnées avec lesfonctions fst (première coordonnée) et snd (seconde coordonnée).

fst (3, true);;int = 3

snd (2, 1., false);;Characters 6-20:

snd (2, 1., false);;

^^^^^^^^^^^^^^Error: This expression has type ’a * ’b * ’c

but an expression was expected of type ’d * ’e

3. Structure conditionnelleLa syntaxe d’un test conditionnel est if condition then valeur1 else valeur2.

(* Supposons un entier x défini précédemment *)let y = if x < 0 then -1 else 1;;

Les deux instructions après then et après else doivent être de même type. La condition est néces-sairement un booléen.

16

Chapitre 1 – Prise en main de Caml

COUR

S

let y = if x < 0 then -1 else 1.0;;Characters 32-35:

let y = if x < 0 then -1 else 1.0;;

^^^Error: This expression has type float

but an expression was expected of type int

Plutôt que des valeurs simples, on peut écrire des blocs de plusieurs instructions séparées par des ;avec la syntaxe suivante :

if condition then begininstruction1;instruction2;...instructionN;valeur1

end else begininstruction1bis;instruction2bis;...instructionNbis;valeur2

end

Conseil méthodologiqueLes séparateurs begin...end peuvent être remplacés par (...). De plus, les instructionsprécédant les valeurs doivent nécessairement être de type unit.

let y = if x < 0 thenbegin print_int x; -1 end

else(print_newline (); 1);;

Il est possible de se passer de la partie else valeur2 car CAML interprète l’absence d’alternativecomme else (). Ainsi, s’il n’y a pas d’alternative, le premier bloc d’instructions doit donc êtrede type unit.

if x < 0 then print_int x;;unit = ()

let y = if x < 0 then -1;;Characters 24-26:

let y = if x < 0 then -1;;

^^Error: This expression has type int

but an expression was expected of type unit

17

Option informatique MPSI/MP-MP*

4. Éléments de programmation impérative4.1. RéférencesCommençons par définir les références, un outil important pour la suite. Dans de nombreux langages,il y a ambiguïté entre le nom (l’identificateur) d’une variable et sa valeur. Les références CAML serventà éviter cet écueil. De plus, le contenu d’une référence est modifiable, contrairement aux variablesusuelles (contrairement à ce que le nom « variable » indique).

On les définit avec la syntaxelet nomreference = ref valeur variante de l’affectation habituelle ;si l’identificateur est r, la valeur est alors !r et l’on peut modifier la valeur avec l’affectation :=. Voiciun exemple.

let r = ref 0;;val r : int ref = {contents = 0}

r;;int ref = {contents = 0}

!r;;int = 0

r := !r + 1;;unit = ()

!r;;int = 1

Les références d’entiers sont souvent utilisées comme compteurs que l’on incrémente à chaqueétape de notre programme. Dans le cas particulier des références d’entiers, on dispose donc desinstructions incr r (équivalent à r := !r + 1) et decr r (équivalent à r := !r - 1).

4.2. Structures itérativesÉtudions maintenant les syntaxes de la structure itérative inconditionnelle ou boucle for.

for k = valeur_initiale to valeur_finale doinstruction1;instruction2;...instructionN

done;;

for k = valeur_finale downto valeur_initiale doinstruction1;instruction2;...instructionN

done;;

Cette syntaxe permet d’effectuer le bloc d’instructions pour chaque valeur de k concernée. Lesinstructions doivent être de type unit.

18

Chapitre 1 – Prise en main de Caml

COUR

S

for i = 1 to 5 doprint_int i;print_string " "

done;;1 2 3 4 5 - : unit = ()

S’il n’y a aucune valeur comprise entre valeur_initiale et valeur_finale, il n’y a pas d’erreur :aucune instruction n’est exécutée.

Outre la boucle for, on peut avoir besoin d’une structure itérative conditionnelle ou boucle whiledont voici la syntaxe :

while condition doinstruction1;instruction2;...instructionN

done;;

Cette syntaxe permet d’effectuer le bloc d’instructions tant que la condition booléenne est vraie (etil faudra vérifier qu’elle devient fausse à un moment pour justifier de la terminaison de l’exécution).

let r = ref 1 inwhile !r <= 5 do

print_int !r;incr r;print_string " "

done;;1 2 3 4 5 - : unit = ()

19

MémentoVoici quelques principes élémentaires pour bien appréhender CAML (ce qui ne dispense pas del’apprentissage des différentes syntaxes mais permet de comprendre les messages d’erreur reçus).

Typage

Caml est un langage fortement typé.. Les principaux types simples sont unit, int, float et bool.. De nombreuses opérations ne sont définies que pour un type précis.. L’instruction de test conditionnel, dont les valeurs doivent avoir le même type, est :if condition then valeur1 else valeur2

Programmation impérative

La programmation impérative est une méthode de programmation qui consiste à utiliser unesuccession de commandes qui changent les valeurs de paramètres locaux ou globaux. Cetteprogrammation utilise des structures itératives inconditionnelles et conditionnelles (connuessous le nom générique de boucles).. La valeur d’une référence nommée r s’obtient avec !r et se modifie avec :=. Les instructions des structures itératives sont :for k = valeur_initiale to valeur_finale do

instructionsdone;;

for k = valeur_finale downto valeur_initiale doinstructions

done;;

while condition doinstructions

done;;

20

ExercicesVrai ou faux ?

Vrai Faux

a) L’instruction 2 ** 3;; renvoie int = 8 � �

b) L’instruction 1. + 1.;; renvoie float = 2. � �

c) Les éléments d’un couple sont nécessairement de même type. � �

d) Dans un test conditionnel, on peut se passer d’écrire la partie elsevaleur2.

� �

e) On peut utiliser l’instruction incr avec une référence de flottant. � �

f) Une boucle while termine toujours son exécution en un temps fini. � �

Exercices d’application du chapitre 1

Exercice 11. En utilisant une affectation locale, calculer

1+p

2+p

23

ep

2−1,

ln 17+ sin ln 17p

3+ lnp

3.

2. En utilisant une affectation locale, donner un calcul efficace (avec un seul appel à la fonctionexponentielle) de tanh x (en supposant x déjà défini).

Exercice 2Donner le type retourné par les instructions suivantes

(1, 2, 3, 4);;1, 2, 3, 4;;(1, 2), 3, 4;;(1, 2), (3, 4);;

Sont-elles équivalentes ?

Exercice 3Déterminer le résultat de l’évaluation des instructions suivantes ou si elles comportent des erreurs.

1. let x = 1 and y = 3 in let x = 2 in x + y;;2. let x, y, z = 1, 2, 3 in x + y + z;;3. let x, y, z = 1, (2, 3) in x + y + z;;4. let x, y, z = true, 2, 3 in x || y = z;;5. let x, y, z = true, 2, 3 in x and y < z;;

21

JEM’ENTR

AÎNE

Option informatique MPSI/MP-MP*

Exercice 4Pourquoi CAML n’accepte pas les instructions suivantes? Les rectifier en supposant que m est unflottant.

let n = 1 + sqrt m;;

let n = if m = 0 then m else sqrt m;;

Exercice 5On considère la suite définie par u0 = 1 et pour n ∈N, un+1 = sin un .

1. Écrire une suite d’instructions calculant u50.2. Écrire une suite d’instructions permettant de déterminer le plus petit entier n tel que

un ≤ 0, 001.

Exercices d’approfondissement du chapitre 1

Exercice AÉcrire une suite d’instructions affichant tous les entiers de 1 à 1 000 qui sont soit des multiples de 23,soit des carrés parfaits.

Exercice BSi n est un entier, écrire une suite d’instructions qui affiche la décomposition de n en produits defacteurs premiers. Par exemple, la décomposition de 3 500 est censée afficher

2^2 5^3 7- : unit = ()

On utilisera print_string pour afficher des caractères.

22

CORR

IGÉS

Corrigés

Corrigés des Vrai/Fauxa) Faux, l’exponentiation ** requiert des flottants.

b) Faux, l’instruction + est l’addition entre entiers.

c) Faux.

d) Vrai si valeur1 est de type unit.

e) Faux.

f) Faux, la condition peut ne jamais être fausse.

Corrigés des exercices d’application du chapitre 1

Exercice 1let a = sqrt 2. in (1. +. a +. a ** 3.) /. (exp a -. 1.);;let a = log 17. and b = sqrt 3. in (a +. sin a) /. (b +. log b);;let y = let a = exp (2. *. x) in (a -. 1.) /. (a +. 1.);;

Exercice 2On obtient successivement

int * int * int * int = (1, 2, 3, 4)int * int * int * int = (1, 2, 3, 4)(int * int) * int * int = ((1, 2), 3, 4)(int * int) * (int * int) = ((1, 2), (3, 4))

Seules les deux premières sont identiques. On remarque ici qu’en informatique, il n’y a pas d’identifi-cation naturelle entre Z4, Z2×Z×Z et Z2×Z2 à cause de la syntaxe distincte des objets considérés.

Exercice 31. int = 5. La première affectation locale à x n’est pas utilisée (d’où un message d’avertissementde la part de CAML).2. int = 63. Message d’erreur : pour CAML, la variable y se voit affecter le couple (2, 3) et z n’a donc pasd’affectation.4. bool = true5. Message d’erreur : le and n’est pas un opérateur booléen, mais le mot-clé de l’affectation simulta-née.

23

Option informatique MPSI/MP-MP*

Exercice 4Dans les deux cas, il y a un problème de typage car la fonction sqrt prend un argument de typefloat et renvoie un float. L’addition est impossible dans le premier cas et il y a incohérence detype dans les deux possibilités du test conditionnel. En corrigeant, on obtient :

let n = 1. +. sqrt m;;

let n = if m = 0. then m else sqrt m;;

Exercice 51. On utilise ici une référence de flottants qu’on met à jour dans une boucle for.

let u = ref 1. infor i = 1 to 50 do

u := sin !udone;!u;;

2. On utilise ici une boucle while et deux références.

let u = ref 1. and n = ref 0 inwhile !u > 0.001 do

u := sin !u;incr n

done;!n;;

Corrigés des exercices d’approfondissement duchapitre 1

Exercice ANotons qu’il est possible de repasser par les flottants et la fonction sqrt pour tester si un nombreest un carré parfait. Pour éviter cela, on utilisera une référence d’entier permettant de garder enmémoire les carrés déjà rencontrés. De plus, l’incrémentation de la référence se fait seulement sinécessaire. Pas besoin de else ici, car les instructions sont de type unit.

let n = ref 1 infor i = 1 to 1000 do

if i = !n * !n || i mod 23 = 0 then beginprint_int i;print_newline ()

end;if i = !n * !n then incr n

done;;

24

CORR

IGÉS

Chapitre 1 – Prise en main de Caml

Exercice BOn va parcourir tous les entiers de 2 à b

pn c. Pour l’un de ces entiers stocké dans la référence d, on

calcule la valuation v associée (en divisant n par ce facteur) puis on affiche le résultat.

let n = 3500 inlet d = ref 2 and m = ref n inwhile !d * !d <= !m do

let v = ref 0 inwhile !m mod !d = 0 do

m := !m / !d;incr v

done;if !v > 0 then begin

print_int !d;if !v > 1 then begin

print_string "^";print_int !v

end;print_string " "

end;incr d

done;if !m > 1 then print_int !m;;

La dernière ligne sert à traiter le cas où n est premier (donc n’admet pas de diviseur entre 2 et bp

n c).

25

VUIBERT

N. Carré • R. Mansuy

OPTIONINFORMATIQUE

MPSI • MP/MP*

VUIBERT

SOMMAIRE :

Partie I : Bases de la programmation 1. Prise en main de Caml – 2. Fonctions – 3. Structures de données – 4. Listes – 5. Tableaux 6. Arbres – 7. Analyse d’algorithmes Partie II : Programmation avancée 8. Programmation dynamique – 9. Diviser pour régner – 10. Arbres binaires – 11. Graphes

Partie III : Langages, automates12. Mots, langages, motifs – 13. Automates – 14. Langages rationnels

Partie IV : Logique15. Expressions logiques – 16. Satisfiabilité

Tous les chapitres comportent différents types d’exercices corrigés.À la fin de chaque partie, on trouvera des problèmes type concours.En annexe le programme d’option informatique en MPSI et MP/MP*.

LES AUTEURS :Nathaniel Carré est professeur en CPGE au lycée Louis-le-Grand à Paris.Roger Mansuy est professeur en CPGE au lycée Saint-Louis à Paris.

ISBN : 978-2-311-40683-2

, la collection idéale pour assurer sa réussite en CPGE scientifiques.Ce manuel Tout-en-un propose :- un cours de référence, conforme au programme, illustré d’exemples et de démonstrations ;

- de nombreux encarts pour mieux se repérer ;- des conseils méthodologiques pour éviter les erreurs ;- des fiches « Mémento » pour retenir l’essentiel et réviser ;- plus de 180 exercices, problèmes et sujets de concours pour s’entraîner ;- tous les corrigés détaillés et commentés.

MPSIMP

MP*OPTION INFORMATIQUE MPSI • MP/MP*

OPTI

ON IN

FORM

ATIQ

UE

Tout-en-unÀ jour du passage en langage OCaml Tout le cours Conseils méthodologiques Fiches Mémento Vrai/faux Exercices d’application Exercices d’approfondissement Problèmes type concours Tous les corrigés détaillés

2e ÉDITION ACTUALISÉE

2e ÉDITION ACTUALISÉE