l'informatique au lycée

L'informatique au lycée

Didier Müller

Version 2011

Le contenu de cet ouvrage est publié sous la licence :Creative Commons BY-SA

L'informatique au lycée Avant-propos

Avant-propos« La science informatique n'est pas plus la science des ordinateurs que l'astronomie n'est celle des télescopes. »

Edsger Dijkstra

Public cibleCe cours s'adresse à des lycéens et à tous ceux qui s'intéressent à l'informatique, mais qui ne

savent pas exactement ce que ce terme recouvre. Son objectif est de donner une bonne idée des problèmes que se pose un informaticien.

Pré-requisA partir du chapitre 5, la plupart des exemples sont écrits dans un langage de programmation

appelé Python 3. Bien que ce langage soit très lisible, il est préférable le connaître au préalable. Je recommande chaudement le livre de Gérard Swinnen Apprendre à programmer avec Python 3, disponible en librairie ou en ligne, à cette adresse :

www.nymphomath.ch/python3/

C'est quoi, l'informatique ?Si vous demandez à dix personnes : « C'est quoi, l'informatique ? », vous obtiendrez sans doute

dix réponses différentes. Chacun de vos interlocuteurs décrira probablement l'usage qu'il fait d'un ordinateur : la secrétaire vous parlera de traitement de texte, l'économiste de tableur, le graphiste de traitement d'images, l'ingénieur de programmation, l'adolescent de jeux vidéo, la bibliothécaire de base de données, etc. Ce sont des exemples de ce qu'on peut faire avec un ordinateur, mais est-ce vraiment cela, l'informatique ?

Voyons ce que dit le dictionnaire « Le Petit Robert » :

Informatique : Science du traitement de l'information ; ensemble des techniques de la collecte, du tri, de la mise en mémoire, du stockage, de la transmission des informations traitées automatiquement à l'aide de programmes mis en œuvre sur ordinateurs.

Voilà qui est très général ! On apprend en tout cas que l'informatique est une science (d'ailleurs en anglais, « informatique » se dit « Computer science »). Précisons encore d'autres termes :

Programme : Ensemble des instructions, rédigé dans un langage de programmation, permettant à un système informatique d'exécuter une tâche donnée.

Ordinateur : Machine électronique de traitement numérique de l'information, exécutant à grande vitesse les instructions d'un programme enregistré.

Informaticien : spécialiste en informatique, théorique ou appliquée => analyste, concepteur, développeur, programmeur.

Didier Müller 0-1 Octobre 2011

http://www.apprendre-en-ligne.net/python3/


But de ce coursLe but de ce cours est de passer du côté obscur de l'informatique et de présenter cette science du

point de vue d'un ingénieur informaticien, tout en restant accessible. Il ne s'agit pas de faire un cours universitaire, mais de survoler certains des domaines les plus intéressants de l'informatique :

• Histoire de l'informatique (chapitre 1). Qui sont les inventeurs de l'informatique ? Quelles sont les grandes dates ?

• Comment ça marche ? (chapitre 2). Comment fonctionne un ordinateur, un disque dur, une clé USB, Google, etc. ?

• Codage de l'information (chapitre 3). Comment des 0 et des 1 peuvent-ils représenter des textes, des chiffres, des images ? Comment repérer et corriger les erreurs de transmission ?

• Systèmes logiques (chapitre 4). Qu'est-ce que l'algèbre de Boole, les portes logiques ?• Programmation (chapitre 5). Qu'est-ce qu'on appelle « Programmation » ? Que sont des

langages de programmation ?• Structures de données (chapitre 6). Quelle est la meilleure façon d'organiser un ensemble

de données (des nombres, des textes, ...) pour y accéder rapidement ? Qu'est-ce qu'une file, une pile, un arbre binaire, etc. ?

• Algorithmique (chapitre 7). Quelles sont les méthodes les plus efficaces pour traiter un problème donné (trier un ensemble d'objets, trouver un objet minimal d'un ensemble, multiplier deux entiers, etc.) ?

• Intelligence artificielle (chapitre 8). Comment un ordinateur peut-il jouer contre un humain ? Qu'est-ce que l'on appelle « intelligence artificielle » ? Est-ce vraiment de l'intelligence ?

• Bases de données (chapitre 9). Comment stocker des informations et comment les retrouver ? Par exemple, comment gérer une bibliothèque scolaire ?

• Sécurité informatique (chapitre 10). Quels sont les types d'attaques des pirates informatiques ? Comment s'en protéger ?

Site web compagnonCe cours est un livre étendu. Vous trouverez pour chaque chapitre des compléments (vidéos,

programmes interactifs, corrigés, ...) sur le site www.nymphomath.ch/info/. Les pages web sont signalées par des QRCodes en début de chapitre. Par exemple :

http://ow.ly/2xwnN

Vous pouvez accéder à ces pages soit en tapant l'adresse url, soit en pointant le pictogramme avec la caméra de votre téléphone portable (après avoir téléchargé une application d'un lecteur de QRCodes disponible sur Internet pour la plupart des smartphones).


http://ow.ly/2xwnN

http://www.nymphomath.ch/info/


Table des matières1. Une petite histoire de l'informatique

2. Comment ça marche2.1. Fonctionnement général d'un ordinateur................................................................................................................2-12.2. À l'intérieur d'un ordinateur...................................................................................................................................2-32.3. Les mémoires.........................................................................................................................................................2-62.4. Le BIOS.................................................................................................................................................................2-72.5. Le système d'exploitation.......................................................................................................................................2-82.6. Le disque dur..........................................................................................................................................................2-92.7. Clé USB...............................................................................................................................................................2-122.8. Internet.................................................................................................................................................................2-142.9. World Wide Web..................................................................................................................................................2-162.10. Google..................................................................................................................................................................2-192.11. Les réseaux pair-à-pair.........................................................................................................................................2-222.12. L'informatique dans les nuages............................................................................................................................2-23

3. Codage de l'information3.1. Vocabulaire............................................................................................................................................................3-13.2. Les bases décimale, binaire et hexadécimale.........................................................................................................3-13.3. Représentation des nombres entiers.......................................................................................................................3-33.4. Représentation des nombres réels..........................................................................................................................3-53.5. Le code ASCII........................................................................................................................................................3-73.6. Codage des couleurs..............................................................................................................................................3-93.7. Formats d'images...................................................................................................................................................3-93.8. Stéganographie.....................................................................................................................................................3-133.9. Codes correcteurs d'erreurs..................................................................................................................................3-143.10. Les codes-barres...................................................................................................................................................3-183.11. Codage de Huffman.............................................................................................................................................3-21

4. Algèbre booléenne et circuits logiques4.1. L'algèbre de Boole.................................................................................................................................................4-14.2. Fonctions logiques et tables de vérité....................................................................................................................4-24.3. Tables de Karnaugh................................................................................................................................................4-34.4. Circuits logiques....................................................................................................................................................4-6

5. Programmation et langages5.1. Un peu d'histoire....................................................................................................................................................5-15.2. La machine de Turing............................................................................................................................................5-55.3. Pseudo-code...........................................................................................................................................................5-75.4. Transformation du code source..............................................................................................................................5-95.5. Paradigmes...........................................................................................................................................................5-105.6. Les notions principales de programmation..........................................................................................................5-125.7. La programmation orientée objet.........................................................................................................................5-20



6. Structures de données avancées6.1. Pile.........................................................................................................................................................................6-16.2. File.........................................................................................................................................................................6-26.3. Arbres.....................................................................................................................................................................6-36.4. Arbres binaires.......................................................................................................................................................6-46.5. Arbres binaires de recherche..................................................................................................................................6-66.6. Rotations d'équilibrage..........................................................................................................................................6-76.7. Arbres AVL............................................................................................................................................................6-96.8. Tas........................................................................................................................................................................6-116.9. Table de hachage..................................................................................................................................................6-13

7. Algorithmique7.1. Quelques définitions..............................................................................................................................................7-17.2. Les tours de Hanoi.................................................................................................................................................7-27.3. Le problème des huit dames..................................................................................................................................7-47.4. Algorithmes gloutons.............................................................................................................................................7-67.5. Algorithmes de tri..................................................................................................................................................7-87.6. Tester si un point est dans un polygone...............................................................................................................7-127.7. Enveloppe convexe..............................................................................................................................................7-147.8. Recherche de nombres premiers..........................................................................................................................7-167.9. Algorithmes probabilistes....................................................................................................................................7-167.10. Le problème des n dames pour illustrer les métaheuristiques.............................................................................7-19

8. Intelligence artificielle et jeux8.1. Différents types de jeux.........................................................................................................................................8-28.2. Jeu avec stratégie gagnante : Marienbad...............................................................................................................8-58.3. Utilisation de la force brute : Mastermind.............................................................................................................8-58.4. Les trois piliers d'un jeu de stratégie......................................................................................................................8-78.5. Othello..................................................................................................................................................................8-12

9. Bases de données9.1. Un exemple pour tout expliquer rapidement.........................................................................................................9-19.2. Les bases de données relationnelles.......................................................................................................................9-39.3. Modèle entité-association......................................................................................................................................9-49.4. Traduction du schéma conceptuel en un modèle relationnel.................................................................................9-69.5. Le langage SQL.....................................................................................................................................................9-89.6. EasyPHP et mySQL.............................................................................................................................................9-109.7. Exemples de bases de données............................................................................................................................9-18

10. Sécurité informatique10.1. Logiciels malveillants..........................................................................................................................................10-110.2. Attaques et fraudes...............................................................................................................................................10-510.3. Intégrité..............................................................................................................................................................10-1010.4. Piratage informatique.........................................................................................................................................10-1110.5. Cryptographie moderne.....................................................................................................................................10-1610.6. Authentification.................................................................................................................................................10-18


L'informatique au lycée Chapitre 1

http://ow.ly/2wZ7L

Chapitre 1Une petite histoire de

l'informatique1er siècle avant J.-C.Datée d'avant 87 av. J.-C, la machine d'Anticythère est une calculatrice mécanique antique

permettant de calculer des positions astronomiques. C'est le plus vieux mécanisme à engrenages connu.

1623Wilhelm Schickard (1592-1635) invente pour Kepler une « horloge calculante » destinée à

calculer les éphémérides.

1642-1644Blaise Pascal (1623-1662) invente une machine à calculer (« la Pascaline ») capable

d'additionner et de soustraire des nombres de huit chiffres.

1673Gottfried Wilhelm von Leibniz s'inspire de la Pascaline et invente une machine capable de

multiplier et diviser sans utiliser les additions successives. Elle ne sera construite qu'en 1694, faute de trouver un artisan assez habile.

Didier Müller 1-1 août 2010

http://ow.ly/2wZ7L

Une petite histoire de l'informatique

1801Joseph Marie Jacquard (1752-1834) invente des cartes pour commander le tissage de motifs sur

les métiers à tisser. On peut considérer cette invention comme le début de la programmation.

1823Charles Babbage (1791-1871) commence à construire sa machine à différences, inspiré par le

métier à tisser de Jacquard.Babbage caresse l'idée de cette machine depuis 1812. Il s'adjoint l'aide d'une jeune femme, Ada

Lovelace (1815-1852), brillante mathématicienne qui l'aide à concevoir les « diagrammes » pour faire fonctionner la machine. Il semblerait que c'est Lady Ada qui conçoit le premier langage informatique pour la machine à différences de Babbage (elle donnera d'ailleurs son nom au langage de programmation Ada), mais d'autres biographes pensent qu'elle a seulement corrigé une erreur de Babbage.

Dans une correspondance avec Sir Humphry Davy en 1822, Babbage y discute de certaines applications d'une telle machine, notamment pour le calcul et l'impression des tables mathématiques, et y discute aussi des principes d'une machine à calculer. En 1823 débute la construction de cette machine qui ne sera jamais complétée. En 1991, on a pu reconstruire à partir de ses plans une partie de cette machine, qui fonctionna parfaitement.

1854George Boole (1815-1864) publie un article sur la logique binaire. Les travaux de Boole, s'ils

sont théoriques, n'en trouveront pas moins des applications primordiales dans les systèmes informatiques.

1890Herman Hollerith (1860-1929) utilise une machine à cartes perforées pour le dépouillement du

recensement américain.

1936Alan Mathison Turing (1912-1954) publie On Computable Numbers with an Application to the

Entscheidungsproblem, ouvrage qui définit les limites théoriques de l'ordinateur. Il présente le modèle des machines de Turing et construit (mathématiquement) la première machine universelle. Il prouve également l'absence de méthodes algorithmiques (indécidabilité algorithmique) pour résoudre certains problèmes comme le problème de l'arrêt ou le problème de la décision.



Alan Turing se suicidera en 1954, en mangeant une pomme imbibée de cyanure. Une légende souvent rapportée dit que cet épisode est à l'origine du logo d'Apple.

1937

Le premier ordinateur, nommé ABC pour Atanasoff-Berry Computer est conçu par John Vincent Atanasoff (1903-1995) avec son étudiant Clifford Berry (1918-1963). Il a été testé avec succès en 1942.

Les idées d'Atanasoff (utilisation du binaire, utilisation d'une unité arithmétique et logique pour effectuer les calculs de base) furent reprises dans l'ENIAC, souvent considéré ainsi à tort comme le premier ordinateur. En effet, Eckert et Mauchly, concepteurs de l'ENIAC, brevètent leur invention comme le premier ordinateur (« first digital computer »), mais un procès dans les années 1970, juge qu'ils n'ont fait que reprendre les idées de l'ordinateur ABC, et consacre ainsi Atanasoff comme l'inventeur du premier ordinateur électronique.

1940Pour décrypter les messages de l'armée Allemande, les Anglais mettent au point sur le site de

Bletchley Park les calculateurs Robinson et Colossus sous la direction du mathématicien Alan Turing. Ce sont les premières machines qui intègrent les concepts d'arithmétique binaire, d'horloge interne, de mémoire tampon, de lecteurs de bande, d'opérateurs booléens, de sous-programmes et d'imprimantes. Tout ceci sera classé « Secret défense » jusqu'en 1975.

1941Konrad Zuse (1910-1995) fait fonctionner le premier ordinateur du monde, le Z3 (ou Zuse 3).

Encore largement méconnu, il est l'un des pères de l'informatique en ayant développé le premier calculateur électromécanique Z1 en 1938. Le Z3 fut détruit en 1944 par les bombardements alliés et servait à produire des calculs pour une usine aéronautique allemande.

Il concevra aussi et réalisera entre 1942 et 1946 le premier langage de haut niveau nommé Plankalkül. Ce langage est extrêmement innovant, mais en dehors du courant principal du développement de l'informatique. Il demeure donc très largement inconnu.

1943Création du ASCC Mark I (Automatic Sequence-Controlled Calculator Mark I) à Harvard par

Howard Aiken (1920-1973) et son équipe, avec le soutien d'IBM. C'est un énorme calculateur électromécanique (3000 relais, 800 km de câbles) qui permet de faire 3 opérations sur 23 chiffres par seconde. Cette machine est très proche dans son principe de fonctionnement des plans de la machine analytique de Babbage. Le programme est lu depuis une bande de papier ; les données à traiter peuvent être lues depuis une autre bande de papier ou un lecteur de cartes.



1943L'ENIAC (Electronic Numerical Integrator And Computer) est créé par John W. Mauchly (1907-

1980) et John Presper Eckert (1919-1995). Il sera opérationnel en 1946. Son poids est de 30 tonnes pour des dimensions de 2,4 x 0,9 x 30,5 mètres occupant une surface de 67 mètres carrés. Il fut utilisé pour des calculs ayant servi à mettre au point la bombe H. Son principal inconvénient était sa programmation : l'ENIAC était en effet uniquement programmable manuellement avec des commutateurs et des câbles à enficher.

1944John Von Neumann (né Neumann János, 1903-1957) a donné son nom à l'architecture de von

Neumann utilisée dans la quasi- totalité des ordinateurs modernes. Cela est dû au fait qu'il est, en 1944, le rapporteur des travaux pionniers en la matière (First Draft of a Report on the EDVAC1). Le modèle de calculateur à programme auquel son nom reste attaché et qu'il attribuait lui-même à Alan Turing, possède une unique mémoire qui sert à conserver les logiciels et les données. Ce modèle, extrêmement innovant pour l'époque, est à la base de la conception de nombre d'ordinateurs.

L’architecture de von Neumann décompose l’ordinateur en 4 parties distinctes :

1. l’unité arithmétique et logique (UAL) ou unité de traitement, qui effectue les opérations de base ;

2. l’unité de contrôle, qui est chargée du séquençage des opérations ;

3. la mémoire, qui contient à la fois les données et le programme qui indique à l’unité de contrôle quels calculs faire sur ces données. La mémoire se divise en mémoire vive (programmes et données en cours de fonctionnement) et mémoire de masse (programmes et données de base de la machine) ;

4. les dispositifs d’entrée-sortie, qui permettent de communiquer avec le monde extérieur.

1945Un papillon de nuit coincé dans les circuits bloque le fonctionnement du calculateur Mark II. La

mathématicienne Grace Murray Hopper décide alors que tout ce qui arrête le bon fonctionnement d'un programme s'appellera « bug » (bestiole en anglais).

Il faut noter que le terme « bug » était déjà utilisé auparavant : Thomas Edison par exemple avait employé ce terme dans un courrier à propos d'une de ses inventions.

1 EDVAC (Electronic Discrete Variable Automatic Computer) est l'un des tout premiers ordinateurs électroniques. Contrairement à l'ENIAC, il opère en mode binaire plutôt que décimal.



1951Grace Murray Hopper (1906-1992) conçoit le premier compilateur, nommé A-0 System. À

partir de 1957, elle travaille pour IBM, où elle défend l'idée qu'un programme devrait pouvoir être écrit dans un langage proche de l'anglais plutôt que d'être calqué sur le langage machine, comme l'assembleur. De cette idée naîtra le langage COBOL en 1959.

1954Création du Fortran, premier langage de programmation à être implémenté sur un ordinateur.

1962Philippe Dreyfus invente le mot « informatique », mot-valise né de la contraction des mots

« information » et « automatique ».

1963Création de la souris par Douglas Engelbart du Stanford Research Institute.

Fin 1969Début du réseau Arpanet, renommé plus tard Internet. Il compte 4 nœuds.

1973Commercialisation du Micral, le premier micro-ordinateur. Il a été développé de 1972 à 1973 par

R2E, jeune société Française dirigée par André Truong (1936-2005), mais c'est François Gernelle (1944-) qui en est l'inventeur (photo ci-contre). Cet ordinateur ne possédait ni clavier ni écran et était commandé par des interrupteurs, comme l'Altaïr, deux ans plus tard.

1975L'Altair 8800 du constructeur américain MITS est un micro-ordinateur basé sur le

microprocesseur Intel 8080A vendu en kit électronique à quelques milliers d'exemplaires pour les particuliers en 1975. Il est considéré par les Américains comme le premier micro-ordinateur.

1976Apparition du premier supercalculateur : le Cray I.Chess 4.5 remporte la Classe B du tournoi Paul Masson de Californie du Nord. Sa performance

Elo est alors de 1950. C'est la première fois qu'un ordinateur remporte un tournoi « humain ».

1985Apparition du CD-ROM.



1989Tim Berners-Lee invente le World Wide Web (WWW) pour que les chercheurs puissent partager

les informations au sein du CERN.

1997Deep Blue bat Gary Kasparov sur le score de 3,5-2,5. Deep Blue est un superordinateur

spécialisé dans le jeu d'échecs, développé par IBM. C'est la première fois qu'un ordinateur bat un champion du monde d'échecs.

1998La société Google, Inc. est fondée le 27 septembre 1998 dans la Silicon Valley, en Californie, par

Larry Page et Sergey Brin, créateurs du moteur de recherche Google.

2001Wikipedia est une encyclopédie numérique ouverte, libre, multilingue, consultable gratuitement

sur internet et en évolution permanente grâce à de très nombreux contributeurs bénévoles. Son succès est considérable et sa croissance exponentielle : créée en janvier 2001 par Jimmy Wales, elle est devenue un des 10 sites les plus consultés au monde.

2004Mark Zuckerberg fonde « The Facebook », initialement à l'adresse thefacebook.com, le 4 février

2004. L'inscription a d'abord été limitée aux étudiants de l'université Harvard.

2006Twitter est ouvert au public le 13 juillet 2006.

Sources[1] Rossi Serge, « Histoire de l'informatique », <http://histoire.info.online.fr/>

[2] Wikipédia, « Chronologie de l'informatique », <http://fr.wikipedia.org/wiki/Chronologie_informatique>

[3] Breton Philippe, Une histoire de l'informatique, Éditions La découverte, 1987

[4] Ellenberger Michel, Collin Marie-Marthe, La machine à calculer de Blaise Pascal, Éditions Nathan, 1993

[5] Strathern Paul, Turing et l'ordinateur, je connais !, Mallard Editions, 1998

[6] Les Cahiers de Sciences & Vie, Qui a inventé l'ordinateur ?, HS No 36, Décembre 1996



Mots croisés

1 2 3 4

5

6

7 8

9 10

11 12

13 14

15

16 17

Horizontalement

1. Concepteur de la "machine à différences"6. Informaticienne américaine qui a conçu le premier compilateur7. Prénom de la collaboratrice de Babbage et langage de programmation10. Lieu où a été inventé le World Wide Web11. Le "A" de l'ordinateur ABC13. Créateur de Facebook14. Nom du premier supercalculateur15. Nom du premier langage de programmation de haut niveau16. Inventeur de la première calculatrice capable de multiplier17. Firme fondée par Larry Page et Sergey Brin

Verticalement

2. Ancêtre d'Internet3. Electronic Numerical Integrator And Computer4. A construit la première machine universelle5. Inventeur de la logique binaire8. Plus vieux mécanisme à engrenages connu9. A donné son nom à l'architecture utilisée dans la quasi-totalité des ordinateurs modernes12. Nom du premier micro-ordinateur13. Informaticien allemand ayant fait fonctionner le premier ordinateur du monde



http://ow.ly/3hY4u

Chapitre 2Comment ça marche ?

2.1. Fonctionnement général d'un ordinateur

Le mot ordinateur fut introduit par IBM France en 1955. François Girard, alors responsable du service publicité de l'entreprise, eut l'idée de consulter son ancien professeur de lettres à Paris, Jacques Perret, afin de lui demander de proposer un mot caractérisant le mieux possible ce que l'on appelait vulgairement un calculateur (traduction littérale du mot anglais « computer »). Ce dernier proposa « ordinateur », un mot tombé en désuétude désignant anciennement celui qui confère un ordre ecclésiastique (ordinant). Le professeur suggéra plus précisément « ordinatrice électronique », le féminin ayant pu le différencier de l'usage religieux du mot.

Parmi toutes les machines inventées par l'homme, l'ordinateur est celle qui se rapproche le plus du concept anthropologique suivant :

Organe d'entrée / Organe de traitement de l'information / Organe de sortie

Chez l'homme les organes d'entrée sont les cinq sens, l'organe de traitement est le cerveau et les organes de sortie sont... les muscles.

Pour les ordinateurs modernes, les organes d'entrée sont le clavier et la souris ; les organes de sortie sont l'écran, l'imprimante, le graveur de DVD, etc.

1. Écran2. Carte mère3. CPU (Microprocesseur)4. Mémoire vive (RAM)5. Cartes de périphériques6. Alimentation7. Lecteur de disques (DVD)8. Disque dur9. Souris 10. Clavier

Didier Müller 2-1 Février 2011

http://ow.ly/2xKdB

Comment ça marche ?

Architecture de von NeumannLes techniques utilisées pour fabriquer ces machines ont énormément changé depuis les années

1940 et sont devenues une technologie (c'est-à-dire un ensemble industriel organisé autour de techniques) à part entière depuis les années 1970. Beaucoup utilisent encore les concepts définis par John von Neumann, bien que cette architecture soit en régression : les programmes ne se modifient plus guère eux-mêmes (ce qui serait considéré comme une mauvaise pratique de programmation), et le matériel prend en compte cette nouvelle donne en séparant aujourd'hui nettement le stockage des instructions et des données, y compris dans les caches.

L'architecture de von Neumann décomposait l'ordinateur en quatre parties distinctes :1. L'unité arithmétique et logique (UAL) ou unité de traitement : son rôle est d'effectuer les

opérations de base, un peu comme le ferait une calculette. 2. L'unité de contrôle (UC). C'est l'équivalent des doigts qui actionneraient la calculette. 3. La mémoire qui contient à la fois les données et le programme qui dira à l'unité de contrôle

quels calculs faire sur ces données. La mémoire se divise entre mémoire vive (programmes et données en cours de fonctionnement) et mémoire permanente (programmes et données de base de la machine).

4. Les entrées-sorties : dispositifs qui permettent de communiquer avec le monde extérieur.

Unité arithmétique et logiqueL'unité arithmétique et logique, ou UAL, est l'élément qui réalise les opérations élémentaires

(additions, soustractions, etc.), les opérateurs logiques (ET, OU, NI, etc.) et les opérations de comparaison (par exemple la comparaison d'égalité entre deux zones de mémoire). C'est l'UAL qui effectue les calculs de l'ordinateur.

Unité de contrôleL'unité de contrôle, ou UC, prend ses instructions dans la mémoire. Celles-ci lui indiquent ce

qu'elle doit ordonner à l'UAL et, comment elle devra éventuellement agir selon les résultats que celle-ci lui fournira. Une fois l'opération terminée, l'unité de contrôle passe soit à l'instruction suivante, soit à une autre instruction à laquelle le programme lui ordonne de se brancher.L'unité de contrôle facilite la communication entre l'unité arithmétique et logique, la mémoire ainsi que les périphériques. Il gère la plupart de l'exécution des instructions dans l'ordinateur.

MémoireAu sein du système, la mémoire peut être décrite comme une suite de cellules numérotées

contenant chacune une petite quantité d'informations. Cette information peut servir à indiquer à l'ordinateur ce qu'il doit faire (instructions) ou contenir des données à traiter. Dans la plupart des architectures, c'est la même mémoire qui est utilisée pour les deux fonctions. Cette mémoire peut être réécrite autant de fois que nécessaire.

Entrées-SortiesLes dispositifs d'entrée/sortie permettent à l'ordinateur de communiquer avec l'extérieur (clavier,

écran, imprimantes, etc.).Le point commun entre tous les périphériques d'entrée est qu'ils convertissent l'information qu'ils

récupèrent de l'extérieur en données compréhensibles par l'ordinateur. À l'inverse, les périphériques de sortie décodent l'information fournie par l'ordinateur afin de la rendre compréhensible par l'utilisateur (voir chapitre 3).

BusCes différentes parties sont reliées par trois bus, le bus d'adresse, le bus de données et le bus de

commande. Un bus est un groupement d'un certain nombre de fils électriques réalisant une liaison pour transporter des informations binaires codées sur plusieurs bits.

Le bus d'adresse transporte les adresses générées par l'UCT (Unité Centrale de Traitement) pour sélectionner une case mémoire ou un registre interne de l'un des blocs. Le nombre de bits véhiculés par ce bus dépend de la quantité de mémoire qui doit être adressée.

Le bus de données transporte les données échangées entre les différents éléments du système.



Le bus de contrôle transporte les différents signaux de synchronisation nécessaires au fonctionnement du système : signal de lecture (RD), signal d'écriture (WR), signal de sélection (CS : Chip Select).

2.2. À l'intérieur d'un ordinateur

La carte mère : C'est la pièce de base de l'ordinateur, elle est le support de tous les composants informatiques. Elle est associée au « cerveau » de l'ordinateur : le processeur. Tous les composants et périphériques se branchent directement sur elle.

L'alimentation : Reliée au secteur, elle fournit à l'ordinateur et ses composants une tension transformée, et adaptée à chaque composant. L'alimentation est toujours accompagnée d'un ventilateur sans lequel une surchauffe viendrait endommager irrémédiablement l'ordinateur.

Les lecteurs / graveurs : Le ou les lecteurs permettent de lire un CD-ROM ou un DVD-ROM. Un graveur permet d'écrire des données sur un CD ou DVD. Un graveur est forcément lecteur, mais le contraire n'est pas vrai !

Le disque dur : C'est la « mémoire » de l'ordinateur, sur laquelle on enregistre les données. Un ordinateur peut contenir plusieurs disques dur, et chaque disque dur peut être séparé en plusieurs parties distinctes, appelées partitions.

La carte son : Pas toujours présente sur l'ordinateur, car déjà intégrée à la carte mère, elle permet de brancher des haut-parleurs et un micro. L'acquisition d'une carte son en plus de la carte déjà intégrée améliore le son et permet d'augmenter le nombre d'enceintes (2 seulement avec la carte mère, 7 et + avec une carte son). Elle se branche sur la carte mère sur un port appelé PCI.

La carte graphique : Celle-ci permet l'affichage sur l'écran. Il est préférable d'avoir une carte graphique performante lorsque l'on veut utiliser son ordinateur pour des jeux vidéos, ou du multimédia en tout genre. Une carte graphique de base et à moindre coût suffit largement pour une utilisation simple de l'ordinateur.

2.2.1. La carte mèreLa carte mère (motherboard en anglais) est un circuit imprimé servant à interconnecter toutes les

composantes d'un micro-ordinateur. Comme elle permet aux différentes parties d'un micro-ordinateur de communiquer entre elles, la carte mère est, d'une certaine façon, le système nerveux du micro-ordinateur.



Les oreilles des éléphants jouent aussi le rôle de dissipateur thermique.

1. Ce gros carré blanc est le socket, c'est-à-dire l'emplacement destiné à accueillir le processeur. Dans la mesure où le processeur émet de la chaleur, il est nécessaire de la dissiper pour éviter que ses circuits ne fondent. C'est la raison pour laquelle il est généralement surmonté d'un dissipateur thermique (appelé parfois refroidisseur ou radiateur), composé d'un métal ayant une bonne conduction thermique (cuivre ou aluminium), chargé d'augmenter la surface d'échange thermique du microprocesseur. Le dissipateur thermique comporte une base en contact avec le processeur et des ailettes afin d'augmenter la surface d'échange thermique. Un ventilateur accompagne généralement le dissipateur pour améliorer la circulation de l'air autour du dissipateur et améliorer l'échange de chaleur.

2. Emplacements (slots) destinés à accueillir les barrettes de RAM (Random Access Memory). 3. Ces grandes barres blanches sont destinées à accueillir divers types de cartes (carte son,

modem 56k, carte PCI/Firewire, etc…) : ce sont des ports PCI (Peripheral Component Interconnect)

4. Port AGP (Accelerated Graphic Port). 5. Cette petite puce contient ce qu'on appelle le BIOS (Basic Input/Output System) ; le BIOS

est un petit programme qui permet de vérifier que tous les composants nécessaires au démarrage de l'ordinateur sont bien présents ; un ordinateur ne peut démarrer sans BIOS : en effet, c'est le premier programme qui s'exécute lorsqu'on allume le PC.

6. Cette pile plate sert à alimenter le BIOS ; c'est grâce à elle que l'ordinateur retient l'heure même lorsqu'on l'éteint.

7. Mais à quoi servent ces 4 rectangles ? Celui en haut à droite sert à brancher l'alimentation de la carte mère ; les deux à gauche sont les ports IDE (primaire et secondaire) : ils permettent de connecter des disques durs et des périphériques ATAPI (Advanced Technology Attachment Packet Interface) c'est-à-dire les lecteurs/graveurs de CD/DVD ; le dernier sert à connecter le lecteur disquette.

8. On retrouve sur le côté de la carte mère les ports externes du PC (voir § 2.2.2 ci-après).



2.2.2. Branchements

Les branchements USB permettent de connecter des périphériques tels que des clés USB, des lecteurs MP3, ainsi que la souris et le clavier.

Exercice 2.1Exercice 2.1Identifiez les différents éléments de cette carte mère.

2.3. Les mémoiresOn appelle mémoire tout composant électronique capable de stocker

temporairement des données. On distingue ainsi deux grandes catégories de mémoires :

• La mémoire centrale (appelée également mémoire interne)



permettant de mémoriser temporairement les données lors de l'exécution des programmes. La mémoire centrale est réalisée à l'aide de micro-conducteurs, c'est-à-dire des circuits électroniques spécialisés rapides. La mémoire centrale correspond à ce que l'on appelle la mémoire vive.

• La mémoire de masse (appelée également « mémoire physique » ou « mémoire externe ») permettant de stocker des informations à long terme, y compris lors de l'arrêt de l'ordinateur. La mémoire de masse correspond aux dispositifs de stockage magnétiques, tels que le disque dur, aux dispositifs de stockage optique, correspondant par exemple aux CD-ROM ou aux DVD-ROM, ainsi qu'aux mémoires mortes.

Caractéristiques techniquesLes principales caractéristiques d'une mémoire sont les suivantes : • la capacité, représentant le volume global d'informations (en bits) que la mémoire peut

stocker ; • le temps d'accès, correspondant à l'intervalle de temps entre la demande de lecture/écriture

et la disponibilité de la donnée ; • le temps de cycle, représentant l'intervalle de temps minimum entre deux accès successifs ; • le débit, définissant le volume d'information échangé par unité de temps, exprimé en bits

par seconde ; • la non-volatilité caractérisant l'aptitude d'une mémoire à conserver les données lorsqu'elle

n'est plus alimentée électriquement. Ainsi, la mémoire idéale possède une grande capacité avec des temps d'accès et temps de cycle

très restreints, un débit élevé et est non volatile. Néanmoins les mémoires rapides sont également les plus onéreuses. C'est la raison pour laquelle

des mémoires utilisant différentes technologiques sont utilisées dans un ordinateur.

Les mémoires les plus rapides sont situées en faible quantité à proximité du processeur et les mémoires de masse, moins rapides, servent à stocker les informations de manière permanente.

Mémoire viveLa mémoire vive, généralement appelée RAM (Random Access Memory, mémoire à accès

direct), est la mémoire principale du système : il s'agit d'un espace permettant de stocker de manière temporaire des données lors de l'exécution d'un programme.

En effet, contrairement au stockage de données sur une mémoire de masse telle que le disque dur, la mémoire vive est volatile, c'est-à-dire qu'elle permet uniquement de stocker des données tant qu'elle est alimentée électriquement. Ainsi, à chaque fois que l'ordinateur est éteint, toutes les données présentes en mémoire sont irrémédiablement effacées.

Mémoire morteLa mémoire morte, appelée ROM (Read Only Memory, mémoire en lecture seule) est un type de

mémoire permettant de conserver les informations qui y sont contenues même lorsque la mémoire n'est plus alimentée électriquement. À la base, ce type de mémoire ne peut être accédée qu'en lecture. Toutefois il est désormais possible d'enregistrer des informations dans certaines mémoires de type ROM.

Mémoire flashLa mémoire flash est un compromis entre les mémoires de type RAM et les mémoires mortes. En

effet, la mémoire Flash possède la non-volatilité des mémoires mortes tout en pouvant facilement



être accessible en lecture ou en écriture. En contrepartie, les temps d'accès des mémoires flash sont plus importants que ceux de la mémoire vive.

Mémoire cacheLa mémoire cache accélère le fonctionnement de l'ordinateur en stockant les données utilisées le

plus récemment. C'est la mémoire la plus rapide de tout l'ordinateur. Elle peut se trouver à l'intérieur du processeur (mémoire cache interne) ou à l'extérieur (mémoire cache externe).

Attention ! Ne faites des modifications dans le Setup qu'en connaissance de cause...

2.4. Le BIOSLe BIOS (Basic Input/Output System) est le programme

basique servant d'interface entre le système d'exploitation et la carte mère. Le BIOS est stocké dans une ROM, ainsi il utilise les données contenues dans le CMOS1 pour connaître la configuration matérielle du système.

Lorsque le système est mis sous-tension ou réamorcé (Reset), le CPU est lui aussi réamorcé et le BIOS va effectuer un certain nombre d'opérations :

• faire le test du CPU, • vérifier le BIOS, • initialiser le timer (l'horloge interne),• vérifier la mémoire vive et la mémoire cache,• vérifier toutes les configurations (clavier, disquettes, disques durs ...),• etc.

La plupart des BIOS ont un « setup » (programme de configuration) qui permet de modifier la configuration basique du système. Ce type d'information est stockée dans une RAM auto-alimentée afin que l'information soit conservée même lorsque le système est hors tension (nous avons vu que la mémoire vive était réinitialisée à chaque redémarrage).

Il est possible de configurer le BIOS grâce à une interface (nommée BIOS setup, configuration du BIOS) accessible au démarrage de l'ordinateur par simple pression d'une touche bien définie.

1 CMOS : Complementary Metal Oxide Semi-conductor (en fait c'est normalement « C-MOSFET »). Type de composant électronique à faible consommation électrique. Par extension, petite mémoire contenant et sauvegardant (grâce à une petite pile ou une batterie) les informations de base nécessaires au fonctionnement de l'ordinateur et de son BIOS, comme, par exemple, la date et l'heure, les caractéristiques du disque dur, etc.



Connaissez-vous ces logos de systèmes d'exploitation ?

La version 2.4 du noyau Linux compte plus de 2 millions de lignes de code !

2.5. Le système d'exploitationPour qu'un ordinateur soit capable de faire fonctionner un programme

informatique (appelé parfois application ou logiciel), la machine doit être en mesure d'effectuer un certain nombre d'opérations préparatoires afin d'assurer les échanges entre le processeur, la mémoire, et les ressources physiques (périphériques).

Le système d'exploitation (noté SE ou OS, abréviation du terme anglais Operating System), est chargé d'assurer la liaison entre les ressources matérielles, l'utilisateur et les applications (traitement de texte, jeu vidéo, ...). Ainsi, lorsqu'un programme désire accéder à une ressource matérielle, il ne lui est pas nécessaire d'envoyer des informations spécifiques au périphérique, il lui suffit d'envoyer les informations au système d'exploitation, qui se charge de les transmettre au périphérique concerné via son pilote. En l'absence de pilotes, il faudrait que chaque programme reconnaisse et prenne en compte la communication avec chaque type de périphérique !

Le système d'exploitation permet ainsi de « dissocier » les programmes et le matériel, afin notamment de simplifier la gestion des ressources et offrir à l'utilisateur une interface homme-machine simplifiée afin de lui permettre de s'affranchir de la complexité de la machine physique.

Rôles du système d'exploitationLes rôles du système d'exploitation sont divers : • Gestion du processeur : le système d'exploitation est chargé de gérer l'allocation du

processeur entre les différents programmes grâce à un algorithme d'ordonnancement. Le type d'ordonnanceur est totalement dépendant du système d'exploitation, en fonction de l'objectif visé.

• Gestion de la mémoire vive : le système d'exploitation est chargé de gérer l'espace mémoire alloué à chaque application et, le cas échéant, à chaque usager. En cas d'insuffisance de mémoire physique, le système d'exploitation peut créer une zone mémoire sur le disque dur, appelée « mémoire virtuelle ». La mémoire virtuelle permet de faire fonctionner des applications nécessitant plus de mémoire qu'il n'y a de mémoire vive disponible sur le système. En contrepartie cette mémoire est beaucoup plus lente.

• Gestion des entrées/sorties : le système d'exploitation permet d'unifier et de contrôler l'accès des programmes aux ressources matérielles par l'intermédiaire des pilotes (appelés également gestionnaires de périphériques ou gestionnaires d'entrée/sortie).

• Gestion de l'exécution des applications : le système d'exploitation est chargé de la bonne exécution des applications en leur affectant les ressources nécessaires à leur bon fonctionnement. Il permet à ce titre de «tuer» une application ne répondant plus correctement.

• Gestion des droits : le système d'exploitation est chargé de la sécurité liée à l'exécution des programmes en garantissant que les ressources ne sont utilisées que par les programmes et utilisateurs possédant les droits adéquats.

• Gestion des fichiers : le système d'exploitation gère la lecture et l'écriture dans le système de fichiers et les droits d'accès aux fichiers par les utilisateurs et les applications.

• Gestion des informations : le système d'exploitation fournit un certain nombre d'indicateurs permettant de diagnostiquer le bon fonctionnement de la machine.

Composantes du système d'exploitation Le système d'exploitation est composé d'un ensemble de logiciels permettant de gérer les

interactions avec le matériel. Parmi cet ensemble de logiciels on distingue généralement les éléments suivants :

• Le noyau (kernel) représentant les fonctions fondamentales du système d'exploitation telles que la gestion de la mémoire, des processus, des fichiers, des entrées-sorties principales, et des fonctionnalités de communication.

• L'interpréteur de commande (shell, traduisez « coquille » par opposition au noyau)



permettant la communication avec le système d'exploitation par l'intermédiaire d'un langage de commandes, afin de permettre à l'utilisateur de piloter les périphériques en ignorant tout des caractéristiques du matériel qu'il utilise, de la gestion des adresses physiques, etc.

• Le système de fichiers (file system, noté FS), permettant d'enregistrer les fichiers dans une arborescence.

Systèmes multitâchesUn système d'exploitation est dit multitâche (en anglais multithreaded) lorsque plusieurs

« tâches » (également appelées « processus ») peuvent être exécutées simultanément.Les applications sont composées en séquence d'instructions que l'on appelle « processus légers »

(en anglais threads). Ces threads seront tour à tour actifs, en attente, suspendus ou détruits, suivant la priorité qui leur est associée ou bien exécutés séquentiellement.

Un système est dit préemptif lorsqu'il possède un ordonnanceur (aussi appelé planificateur), qui répartit, selon des critères de priorité, le temps machine entre les différents processus qui en font la demande.

Le système est dit à temps partagé lorsqu'un quota de temps est alloué à chaque processus par l'ordonnanceur. C'est notamment le cas des systèmes multi-utilisateurs qui permettent à plusieurs utilisateurs d'utiliser simultanément sur une même machine des applications différentes ou bien similaires : le système est alors dit « système transactionnel ». Pour ce faire, le système alloue à chaque utilisateur une tranche de temps.

Systèmes multi-processeursLe multiprocessing est une technique consistant à faire fonctionner plusieurs processeurs en

parallèle afin d'obtenir une puissance de calcul plus importante que celle obtenue avec un processeur haut de gamme ou bien afin d'augmenter la disponibilité du système (en cas de panne d'un processeur).

Un système multiprocesseur doit donc être capable de gérer le partage de la mémoire entre plusieurs processeurs mais également de distribuer la charge de travail.

Systèmes embarquésLes systèmes embarqués sont des systèmes d'exploitation prévus pour fonctionner sur des

machines de petite taille, telles que des smartphones ou des appareils électroniques autonomes (sondes spatiales, robot, ordinateur de bord de véhicule, etc.), possédant une autonomie réduite. Ainsi, une caractéristique essentielle des systèmes embarqués est leur gestion avancée de l'énergie et leur capacité à fonctionner avec des ressources limitées.

Systèmes temps réelLes systèmes temps réel (real time systems), essentiellement utilisés dans l'industrie, sont des

systèmes dont l'objectif est de fonctionner dans un environnement contraint temporellement. Un système temps réel doit ainsi fonctionner de manière fiable selon des contraintes temporelles spécifiques, c'est-à-dire qu'il doit être capable de délivrer un traitement correct des informations reçues à des intervalles de temps bien définis (réguliers ou non).

2.6. Le disque durLe disque dur est l'organe servant à conserver les données de manière permanente, contrairement

à la mémoire vive, qui s'efface à chaque redémarrage de l'ordinateur.Le disque dur est relié à la carte mère par l'intermédiaire d'un contrôleur de disque dur faisant

l'interface entre le processeur et le disque dur. Le contrôleur de disque dur gère les disques qui lui sont reliés, interprète les commandes envoyées par le processeur et les achemine au disque concerné.

Avec l'apparition de la norme USB, des boîtiers externes permettant de connecter un disque dur sur un port USB ont fait leur apparition, rendant le disque dur facile à installer et permettant de rajouter de la capacité de stockage pour faire des sauvegardes. On parle alors de disque dur externe, par opposition aux disques durs internes branchés directement sur la carte mère, mais il s'agit bien des mêmes disques, si ce n'est qu'ils sont connectés à l'ordinateur par l'intermédiaire d'un boîtier branché sur un port USB.



StructureUn disque dur est constitué non pas d'un seul disque, mais de plusieurs disques rigides en métal,

en verre ou en céramique, empilés à une très faible distance les uns des autres et appelés plateaux (en anglais platters).

Les disques tournent très rapidement autour d'un axe (à plusieurs milliers de tours par minute actuellement) dans le sens inverse des aiguilles d'une montre. Un ordinateur fonctionne de manière binaire, c'est-à-dire que les données sont stockées sous forme de 0 et de 1 (appelés bits). Il existe sur les disques durs des millions de ces bits, stockés très proches les uns des autres sur une fine couche magnétique de quelques microns d'épaisseur, elle-même recouverte d'un film protecteur.

La lecture et l'écriture se fait grâce à des têtes de lecture situées de part et d'autre de chacun des plateaux. Ces têtes sont des électroaimants qui se baissent et se soulèvent pour pouvoir lire l'information ou l'écrire. Les têtes ne sont qu'à quelques microns de la surface, séparées par une couche d'air provoquée par la rotation des disques qui crée un vent d'environ 250km/h ! De plus, ces têtes sont mobiles latéralement afin de pouvoir balayer l'ensemble de la surface du disque.

Cependant, les têtes sont liées entre elles et seulement une seule tête peut lire ou écrire à un moment donné.

L'ensemble de cette mécanique de précision est contenu dans un boîtier totalement hermétique, car la moindre particule peut détériorer la surface du disque. Vous pouvez donc voir sur un disque des opercules permettant l'étanchéité, et la mention « Warranty void if removed » qui signifie littéralement « la garantie expire si retiré » car seuls les constructeurs de disques durs peuvent les ouvrir (dans des salles blanches, exemptes de particules).

Les têtes commencent à inscrire des données à la périphérie du disque (piste 0), puis avancent vers le centre. Les données sont organisées en cercles concentriques appelés pistes, créées par le formatage de bas niveau.



Les pistes sont séparées en quartiers (entre deux rayons) que l'on appelle secteurs, contenant les données (au minimum 512 octets par secteur en général).

On appelle cylindre l'ensemble des données situées sur une même piste sur des plateaux différents (c'est-à-dire à la verticale les unes des autres).

On appelle enfin cluster (ou en français « unité d'allocation ») la zone minimale que peut occuper un fichier sur le disque. En effet le système d'exploitation gère des blocs qui sont en fait plusieurs secteurs (entre 1 et 16 secteurs).

Caractéristiques techniques• Capacité : volume de données pouvant être stockées sur le disque. • Taux de transfert (ou débit) : quantité de données pouvant être lues ou écrites sur le disque

par unité de temps. Il s'exprime en bits par seconde. • Vitesse de rotation : vitesse à laquelle les plateaux tournent, exprimée en tours par minutes

(notés rpm pour « rotations par minute »). La vitesse des disques durs est de l'ordre de 7200 à 15000 rpm. Plus la vitesse de rotation d'un disque est élevée meilleur est le débit du disque. En revanche, un disque possédant une vitesse de rotation élevé est généralement plus bruyant et chauffe plus facilement.

• Temps de latence : temps écoulé entre le moment où le disque trouve la piste et le moment où il trouve les données.

• Temps d'accès moyen : temps moyen que met la tête pour se positionner sur la bonne piste et accéder à la donnée. Il représente donc le temps moyen que met le disque entre le moment où il a reçu l'ordre de fournir des données et le moment où il les fournit réellement. Il doit ainsi être le plus court possible.

• Densité radiale : nombre de pistes par pouce (tpi: Track per Inch). • Densité linéaire : nombre de bits par pouce sur une piste donnée (bpi: Bit per Inch). • Densité surfacique : rapport de la densité linéaire sur la densité radiale.• Mémoire cache (ou mémoire tampon) : quantité de mémoire embarquée sur le disque dur.

La mémoire cache permet de conserver les données auxquelles le disque accède le plus souvent afin d'améliorer les performances globales.

• Interface : il s'agit de la connectique du disque dur.

FragmentationLorsque l'on enregistre un fichier sur le disque (celui-ci étant vide à la base), toutes les

informations concernant ce fichier sont écrites les unes à la suite des autres. Lorsque l'on enregistre un deuxième fichier, celui-ci va s'enregistrer à la suite du premier et ainsi de suite.

Cependant, quand un fichier est effacé, cela génère un espace vide sur le disque. Les fichiers suivants vont combler les « trous », et vont donc être éparpillés en portions de fichiers sur le disque. Cela est d'autant plus vrai que le disque dur a une grosse capacité et possède une grande quantité de fichiers.

Le schéma ci-dessus montre un fichier C enregistré sur le disque dur alors que les blocs bleus et jaunes étaient occupés. Le fichier C remplit les espaces libres. Il se divise en

deux pour y parvenir. Le bloc noir reste libre.



Ainsi, lorsque le système accède à un fichier, la tête du disque va devoir parcourir l'ensemble des endroits où les morceaux du fichier sont enregistrés pour pouvoir lire celui-ci. Cela se traduit donc par une baisse de performances...

La copie, le déplacement et la suppression des fichiers est inévitable, car le système écrit constamment des fichiers temporaires. Il est donc indispensable de recourir à un outil de défragmentation, c'est-à-dire un logiciel capable de réorganiser les fichiers sur le disque dur de telle façon que les parcelles de fichiers soient stockées de manière contiguë afin de former des fichiers plus compacts.

Il est ainsi recommandé d'utiliser régulièrement (une fois par mois environ) un utilitaire de défragmentation, qui va réorganiser les données stockées sur le disque.

RemarqueQuand vous supprimez un fichier, vous n'effacez en fait que sa référence dans la table du contenu

de votre disque. Les données ne sont pas perdues mais la place utilisée par votre fichier est à nouveau disponible et peut être immédiatement réutilisée. C'est pour cette raison qu'il est (souvent) possible de récupérer un fichier effacé par mégarde à l'aide d'un logiciel spécialisé, du moins tant que d'autres données n'ont pas recouverte la zone où était stocké votre fichier. Il faut donc agir vite !

L'introduction de l'USB 3 dans des produits grand public a commencé début 2010.

2.7. Clé USBUne clé USB est un petit média amovible qui se branche sur le port USB d'un ordinateur, ou, plus

récemment, de certaines chaînes Hi-Fi, platines DVD de salon, autoradios, radiocassettes, etc. Une clé USB contient une mémoire flash ou un mini disque dur. Les clés USB sont alimentées par le port USB de l'ordinateur sur lequel elles sont branchées. Elles sont insensibles à la poussière et aux rayures, contrairement aux disquettes, aux CD ou aux DVD, ce qui est un avantage au niveau de la fiabilité. En 2008, les clés commercialisées sont en format USB 2.0. Les clés USB sont relativement standardisées, cependant certaines ne sont pas compatibles avec certains systèmes d'exploitation, nécessitant l'installation d'un pilote.

La capacité d'une clé USB est actuellement de quelques gigaoctets.



Pour archiver vos données, utilisez plutôt un disque dur externe ou un CD-ROM !

Durée de vieLa durée de vie de la clef elle-même n'est pas spécifiée et peut tomber en panne au bout de

quelques mois comme de quelques années, menant à une perte partielle ou totale des données.Les constructeurs annoncent une conservation des données pendant au moins dix ans, voire

beaucoup plus. Computerworld se montre plus réservé et attire l'attention sur les différences importantes existant entre différents modèles dans son article Not all USB drives are created equal. Cette durée vient du fait que la charge électrique stockée qui représente l'information n'est pas parfaitement isolée et peut donc disparaître au bout d'un certain temps... Ce n'est donc pas un support fiable.

PerformancesLes performances dépendent beaucoup de la conception du modèle, incluant le choix des

composants, de l'architecture et du contrôleur mémoire. Des techniques telles que l'amplification d'écriture influent sur les performances. Elles peuvent aussi varier en fonction du système d'exploitation ou du matériel sur lequel elle est utilisée.

Le débit de données varie donc en lecture, en écriture et dépend également du nombre de fichiers copiés et de l'organisation du contenu de la clé. On peut donc avoir des débits de quelques Mo/s à plusieurs dizaines de Mo/s, qui peuvent chuter dans le cas de transfert d'un grand nombre de petits fichiers.

À l'intérieur (64 Mo)

1. Un connecteur USB mâle (type A).2. Un contrôleur USB 2.0. Ce circuit implémente le contrôleur pour l'USB 2.0 et assure une

interface entre des données transmises linéairement et la structure en blocs de la mémoire flash. Il permet d'éviter la gestion bas-niveau de la mémoire et contient un petit microcontrôleur RISC ainsi qu'un peu de RAM et de ROM.

3. JP1 et JP2 : deux connecteurs avec 10 pins, principalement pour les tests et le débogage.4. Mémoire flash qui contient 4 096 blocs indépendants (chacun avec 16 kilooctets), soit 64

mégaoctets au total.5. Un oscillateur à quartz cadencé à 12 MHz.6. Une LED pour indiquer l'activité de la clé.7. Un interrupteur à deux positions pour protéger la clé en écriture.8. Une zone vierge prête à recevoir une autre mémoire flash pour offrir un modèle de 128

mégaoctets sans avoir à créer un autre schéma.



2.8. InternetLe 2 septembre 1969, le professeur Len Kleinrock de l'UCLA (University of California, Los

Angeles) et son équipe, comprenant deux étudiants, Stephen Crocker et Vinton Cerf, parvenaient à échanger quelques données entre deux gros ordinateurs reliés par un câble de 4,5 mètres. Ce premier essai est généralement considéré comme l'événement fondateur d'Arpanet, réseau à l'origine d'Internet quelques années plus tard.

Internet est le réseau informatique mondial qui rend accessibles au public des services comme le courrier électronique et le World Wide Web. Techniquement, Internet se définit comme le réseau public mondial utilisant le protocole de communication IP (Internet Protocol).

Internet ayant été popularisé par l'apparition du World Wide Web au début des années 1990, les deux sont parfois confondus par le public non averti. Le Web est une des applications d'Internet, comme le sont le courrier électronique, la messagerie instantanée et les systèmes de partage de fichiers poste à poste. L'accès à Internet peut être réalisé auprès d'un Fournisseur d'accès (FAI) via divers moyens de télécommunication.

TechniqueInternet est composé d'une multitude de réseaux répartis dans le monde entier. Chaque réseau est

rattaché à une entité propre (université, fournisseur d'accès à Internet, armée) et se voit attribuer un identifiant unique appelé Autonomous System (AS). Afin de pouvoir communiquer entre eux, les réseaux s'échangent des données, soit en établissant une liaison directe, soit en se rattachant à un nœud d'échange (point de peering).

Chaque réseau est donc connecté à plusieurs autres réseaux. Lorsqu'une communication doit s'établir entre deux ordinateurs appartenant à des AS différents, il faut alors déterminer le chemin à effectuer parmi les réseaux. Aucun élément d'Internet ne connaît le réseau dans son ensemble, les données sont simplement redirigées vers un autre nœud selon des règles de routage.

ProtocolesInternet fonctionne suivant un modèle en couches. Les éléments appartenant aux mêmes couches

utilisent un protocole de communication pour s'échanger des informations.Un protocole est un ensemble de règles qui définissent un langage afin de faire communiquer

plusieurs ordinateurs. Chaque protocole a des indications particulières et, ensemble, ils fournissent un éventail de moyens permettant de répondre à la multiplicité et à la diversité des besoins sur Internet. Les principaux sont les suivants :

• IP (Internet Protocol) : protocole réseau qui définit le mode d'échange élémentaire entre les ordinateurs participants au réseau en leur donnant une adresse unique sur le réseau.

• TCP : responsable de l'établissement de la connexion et du contrôle de la transmission. C'est un protocole de remise fiable. Il s'assure que le destinataire a bien reçu les données, au contraire d'UDP.

• HTTP (HyperText Transfer Protocol) : protocole mis en œuvre pour le chargement des pages web.

• HTTPS : pendant du HTTP pour la navigation en mode sécurisé. • FTP (File Transfer Protocol) : protocole utilisé pour le transfert de fichiers sur Internet. • SMTP (Simple Mail Transfer Protocol) : mode d'échange du courrier électronique en envoi. • POP3 (Post Office Protocol version 3) : mode d'échange du courrier électronique en

réception. • IMAP (Internet Message Access Protocol) : un autre mode d'échange de courrier

électronique. • IRC (Internet Relay Chat) : protocole de discussion instantanée. • NNTP (Network News Transfer Protocol) : protocole de transfert de message utilisé par les

forums de discussion Usenet • SSL : protocoles de transaction sécurisée, utilisés notamment pour le paiement sécurisé. • DNS (Domain Name System) : système de résolution de noms Internet.



Circulation de l'informationDans un réseau, l'information qui circule est découpée en unités élémentaires appelées paquets. Il

s'agit d'une suite d'octets suffisamment courte pour pouvoir être communiquée sous forme numérique et sans erreur.

Dans le cas d'Internet, le format des paquets est spécifié par l'Internet Protocol. On parle donc de paquets IP. Quand on récupère un fichier par exemple, son contenu est découpé en petits morceaux inclus dans une multitude de paquets IP qui transitent sur le réseau. Chaque paquet circule indépendamment des autres. Pour cela, il contient un en-tête indiquant entre autres quelle est la destination du paquet. Le protocole IP spécifie que cette destination est identifiée par une suite de 4 octets : son adresse IP (chaque octet est généralement lu comme un nombre entre 0 et 255).

Voici ci-dessous le format de l'en-tête d'un paquet IP, tel que spécifié au bit près dans le standard RFC 791. La première ligne indique la signification des quatre premiers octets du paquet (soit 32 bits), la deuxième, celle des quatre suivants et ainsi de suite. Le reste du paquet est constitué par les données qui transitent dans le paquet (typiquement de l'ordre de 1000 octets).

0 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+|Version| IHL |Type of Service| Total Length |+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+| Identification |Flags| Fragment Offset |+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+| Time to Live | Protocol | Header Checksum |+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+| Source Address |+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+| Destination Address |+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+| Options | Padding |+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

On voit qu'outre l'adresse IP de la destination (cinquième ligne), un paquet IP contient aussi celle de la source (quatrième ligne) et bien d'autres champs comme la version du protocole (quatre premiers bits de la première ligne). La version présentée ici (la plus courante à l'heure actuelle) est la version 4 (IPv4). Tout paquet IPv4 commence par les bits 0100, soit 4 en binaire.

À l'intérieur d'un réseauComment les paquets ainsi formés circulent-ils dans un réseau ? Un réseau est constitué de

routeurs et de liens de communication. Les liens relient les routeurs entre eux à la manière de routes entre les villes d'un pays. Plus précisément, un routeur est une sorte d'aiguilleur qui possède des liens avec d'autres routeurs. Chaque lien est branché au routeur via une interface. La principale activité d'un routeur consiste à... router des paquets.

Toute machine reliée à un des routeurs du réseau peut ainsi communiquer avec toute autre machine reliée à un routeur du réseau. Les machines qui sont ainsi mises en relation par un réseau sont appelées des hôtes.

Entre les réseauxComment les paquets circulent-ils d'un réseau à un autre ? Les hôtes sont généralement reliés à

un réseau local. Pour chaque réseau local, un routeur appelé passerelle relie ce réseau avec l'internet. La seule décision de routage prise par un hôte est d'envoyer un paquet, soit directement à la destination si elle se trouve dans le réseau local, soit à la passerelle sinon.

Tous les routeurs d'un réseau sont gérés par la même organisation. Ils sont reliés entre eux, et savent acheminer des paquets entre eux. Certains des routeurs du réseau peuvent avoir des liens vers des routeurs d'autres réseaux, appelons-les des routeurs frontière (border gateway). Le monde des destinations, vu d'un routeur d'Internet, se sépare donc en deux populations, les destinations qui sont accessibles sans sortir de son propre réseau d'une part, et celles qui sont en dehors de ce réseau d'autre part.

Internet est constitué par un empilement hiérarchique de réseaux, comme le montre la figure ci-après.



Source de l'image : [6]

Représentation schématique de la structure d'Internet.

Le réseau F est par exemple connecté par sa passerelle au réseau E, qui est lui-même un sous-réseau du système autonome A. Le réseau F pourrait par exemple être le réseau

Wifi d'un particulier dont le modem ADSL f (qui fait aussi routeur Wifi) est relié à un routeur e de son fournisseur d'accès à Internet. Ce routeur e fait partie du réseau national E de son fournisseur qui possède une connexion directe avec un système

autonome A internationalement connecté.

Les routeurs des systèmes autonomes possèdent des sortes de méta-tables de routage qui indiquent pour une adresse IP comment atteindre le système autonome où se trouve la destination possédant cette adresse. Plus précisément, chacun de ces routeurs connaît la suite de systèmes autonomes qu'il va falloir traverser pour atteindre la destination. Pour cela, tout routeur frontière connecté au routeur frontière d'un autre système autonome échange avec lui des informations sur les adresses IP gérées par tel ou tel système autonome et sur les interconnexions entre système autonomes selon le protocole de routage BGP (pour « Border Gateway Protocol »).

L'acheminement d'un paquet IP se fait donc généralement ainsi :1. le paquet remonte la hiérarchie de réseau jusqu'à un routeur du système autonome de la

source, 2. il transite ensuite de système autonome en système autonome jusqu'à celui de la destination, 3. il descend la hiérarchie jusqu'à la passerelle en charge du réseau local de la destination, 4. cette passerelle l'envoie à la destination.

2.9. World Wide WebLe World Wide Web, littéralement la « toile (d'araignée) mondiale », communément appelé le

Web, le web, parfois la Toile ou le WWW, est un système hypertexte public fonctionnant sur Internet qui permet de consulter, avec un navigateur, des pages accessibles sur des sites. L'image de la toile d'araignée vient des hyperliens qui lient les pages web entre elles.



Techniquement, rien ne distingue le World Wide Web d'un quelconque autre web utilisant les mêmes technologies ; d'ailleurs d'innombrables webs privés existent.

Fin 2010, la société anglaise spécialisée dans la sécurité internet Netcraft dénombre environ 250 millions de sites web dans le monde.

Saviez-vous que la Suisse présente une des plus fortes densités de noms de domaine du monde ? En moyenne, en 2010, un habitant sur six a son propre nom de domaine mais il y a de grandes différences régionales : dans le canton de Zoug par exemple, un habitant sur trois a déjà un nom de domaine, dans le canton du Jura en revanche, un sur 14 seulement.

2.9.1 Termes rattachés au webL'expression en ligne signifie « connecté à un réseau », en l'occurrence le réseau informatique

Internet. Cette expression n'est pas propre au Web, on la retrouve à propos du téléphone.Un hôte est un ordinateur en ligne. Chaque hôte d'Internet est identifié par une adresse IP à

laquelle correspondent zéro, un ou plusieurs noms d'hôte. Cette terminologie n'est pas propre au Web, mais à Internet.

Une ressource du World Wide Web est une entité informatique (texte, image, forum Usenet, boîte aux lettres électronique, etc.) accessible indépendamment d'autres ressources. Une ressource en accès public est librement accessible depuis Internet. Une ressource locale est présente sur l'ordinateur utilisé, par opposition à une ressource distante (ou en ligne), accessible à travers un réseau.

On ne peut accéder à une ressource distante qu'en respectant un protocole de communication. Les fonctionnalités de chaque protocole varient : réception, envoi, voire échange continu d'informations.

Une URL (Uniform Resource Locator) pointe sur une ressource. C'est une chaîne de caractères permettant d'indiquer un protocole de communication et un emplacement pour toute ressource du Web.

Un hyperlien (ou lien) est un élément dans une ressource associé à une URL. Les hyperliens du Web sont orientés : ils permettent d'aller d'une source à une destination.

HTML (HyperText Markup Language) et XHTML (Extensible HyperText Markup Language) sont les langages informatiques permettant de décrire le contenu d'un document (titres, paragraphes, disposition des images, etc.) et d'y inclure des hyperliens. Un document HTML est un document décrit avec le langage HTML.

Dans un mode de communication client-serveur, un serveur est un hôte sur lequel fonctionne un logiciel serveur auquel peuvent se connecter des logiciels clients fonctionnant sur des hôtes clients.

Un serveur Web est un hôte sur lequel fonctionne un serveur HTTP. Un serveur Web héberge les ressources qu'il dessert.

Un navigateur Web est un logiciel client HTTP conçu pour accéder aux ressources du Web. Sa fonction de base est de permettre la consultation des documents HTML disponibles sur les serveurs HTTP. Le support d'autres types de ressource et d'autres protocoles de communication dépend du navigateur considéré.

Une page Web (ou page) est un document destiné à être consulté avec un navigateur Web. Une page Web est toujours constituée d'une ressource centrale (généralement un document HTML) et d'éventuelles ressources liées automatiquement accédées (typiquement des images).

Un éditeur HTML (ou éditeur Web) est un logiciel conçu pour faciliter l'écriture de documents HTML et de pages Web en général.

Un site Web (ou site) est un ensemble de pages Web et d'éventuelles autres ressources, liées dans une structure cohérente, publiées par un propriétaire (une entreprise, une administration, une association, un particulier, etc.) et hébergées sur un ou plusieurs serveurs Web.

Visiter un site Web signifie « consulter ses pages ». Le terme visite vient du fait que l'on consulte généralement plusieurs pages d'un site, comme on visite les pièces d'un bâtiment.

Une adresse Web est une URL de page Web, généralement écrite sous une forme simplifiée limitée à un nom d'hôte. Une adresse de site Web est en fait l'adresse d'une page du site prévue pour accueillir les visiteurs.

Un hébergeur Web est une entreprise de services informatiques hébergeant (mettant en ligne) sur ses serveurs Web les ressources constituant les sites Web de ses clients.



2.9.2. Web profond (deep web)L'exploration récursive du Web à partir de ressources bien choisies est la méthode de base

programmée dans les robots d'indexation des moteurs de recherche.Le Web profond, ou Web invisible, est la partie du Web qui n'est pas indexée et donc introuvable

avec les moteurs de recherche généralistes. Des études indiquent que la partie invisible du Web représente plus de 99 % du Web. Le Web profond comprend notamment les ressources suivantes :

• les ressources inaccessibles au public, donc aux robots d'indexation2, notamment les pages administratives ou payantes, protégées par un mot de passe ;

• les ressources qui ne sont pas communiquées par des protocoles de communication pris en charge par les robots (souvent ils ne prennent en charge que HTTP et HTTPS) ;

• les ressources dont le format de données n'est pas pris en charge par le robot ; • les ressources listées dans un fichier d'exclusion des robots ; • les ressources exclues pour référencement abusif (spamdexing3) ; • les ressources exclues par le robot car considérées comme trop peu pertinentes ; • les ressources vers lesquelles les hyperliens sont créés dynamiquement en réponse aux

interrogations des visiteurs. Ces dernières ressources proviennent généralement de bases de données et constituent la partie la plus importante du Web profond.

2.9.3. Exploration du WebLe World Wide Web, en tant qu'ensemble de ressources hypertextes, peut être modélisé par un

graphe orienté où les ressources sont les sommets et les hyperliens les arcs. Du fait que le graphe est orienté, certaines ressources peuvent constituer des puits : il n'existe aucun chemin vers le reste du Web. À l'inverse, certaines ressources peuvent constituer des sources en indiquant des liens vers d'autres ressources. Le graphe obtenu n'est pas forcément connexe : il n'est peut-être pas possible de rejoindre un sommet à partir d'un autre...

Un moteur de recherche comme Google est un ensemble de robots qui parcourent le Web de page en page, en suivant les liens entre ces pages, puis qui indexent automatiquement les pages visitées. Trois étapes sont indispensables à son fonctionnement :

• La collecte d'information grâce à des robots (aussi appelés spiders ou crawlers). • L'indexation des données collectées et la constitution d'une immense base de données

nommée « index ». • Le traitement des requêtes, avec en particulier un système d'interrogation de l'index et de

classement des résultats en fonction de critères de pertinence suite à la saisie de mots-clés.

2 Un robot d'indexation (ou littéralement araignée du Web ; en anglais web crawler ou web spider) est un logiciel qui explore automatiquement le Web. Il est généralement conçu pour collecter les ressources (pages web, images, vidéos, documents Word, PDF ou PostScript, etc.), afin de permettre à un moteur de recherche de les indexer.

3 Le spamdexing est un ensemble de techniques consistant à tromper les moteurs de recherche sur la qualité d'une page ou d'un site afin d'obtenir, pour un mot-clef donné, un bon classement dans les résultats des moteurs.



Des documents apparaissent et disparaissent tous les jours : il faut donc constamment réactualiser cette base de données. Aucun moteur de recherche ne peut parcourir la totalité des pages en un jour (ce processus peut prendre plusieurs semaines).

Larry Page

Sergey Brin

2.10. GoogleL'histoire de l'entreprise Google commence par la rencontre de deux étudiants de l'université de

Stanford en 1995. En cette année, Sergey Brin (23 ans) et Larry Page (24 ans) commencent à travailler sur un nouveau moteur de recherche. Ils nomment leur projet BackRub. Ils imaginent un logiciel qui analyserait les relations entre les sites web afin d'offrir des meilleurs résultats que ceux donnés par leurs concurrents de l'époque, Altavista notamment.

Une fois leurs travaux finalisés, les deux étudiants commencent à concrétiser leur projet de moteur de recherche, et à cet effet, achètent un téraoctet de disque dur d'occasion, afin de créer une base de donnée. Cette installation sommaire a pris place dans la chambre de Larry Page.

Les deux entrepreneurs sollicitent des entreprises (Sun Microsystems entre autres), famille et amis, et parviennent finalement à réunir un million de dollars pour fonder la compagnie. Dans la plus pure tradition des pionniers de l'informatique, Google Inc. s'installe dans un garage de Menlo, loué par un ami, en septembre 1998, La société comporte trois personnes : Sergey, Larry et Craig Silverstein qui est aujourd'hui directeur de Google Technology.

Alors que le moteur est toujours en phase version bêta4, il répond à près de 10'000 requêtes par jour. En août 1999, la barre des 3 millions de recherches quotidiennes est franchie.

En décembre 1998, PC Magazine classe Google dans sa liste des 100 meilleurs sites au monde. En février 1999, c'est 500'000 requêtes journalières que Google doit gérer. Devenant trop grand pour le garage qui l'héberge, Google se déplace, en mars, dans un bureau sur l'avenue de l'université de Palo Alto et 8 personnes y travaillent désormais.

Dès janvier 1999, la presse mondiale commence à se faire l'écho des performances de ce nouveau moteur de recherche. Le journal français Le Monde écrit ainsi que le choix technologique de Google « s'avère très efficace à l'usage ». Ainsi, une recherche avec les mots « Bill Clinton » renvoie d'abord au site de la Maison Blanche, alors qu'AltaVista ne fait apparaître le site qu'après des dizaines d'autres références. Autre avantage : Google affiche les mots-clés en gras dans le contexte d'une phrase pour chaque lien, alors qu'Altavista ne fournit, à l'époque, que les liens eux-mêmes.

La société déménage une seconde fois vers son emplacement définitif, le Googleplex, situé à Mountain View, en Californie. Le moteur de recherche, jusque-là en version bêta, achève sa phase de test le 9 septembre. Google assure alors la gestion de 3 millions de recherche par jour.

Le 9 mai 2000, le moteur de recherche est disponible en 10 nouvelles langues : allemand, danois, espagnol, finnois, français, italien, néerlandais, norvégien, portugais et suédois, permettant à la société de pénétrer de nouveaux marchés et de gagner en importance. Tout juste un mois plus tard, en juin 2000, Google est le premier moteur de recherche à avoir référencé un milliard de pages web. L'entreprise cherche à étendre la portée de son moteur en concentrant ses efforts sur l'Asie, avec les versions chinoise, japonaise et coréenne (12 septembre), puis au monde entier, totalisant 26 langues dès le 27 mars 2001. Fin octobre 2000, Google signe un partenariat avec Yahoo! et commence à proposer de la publicité ciblée en fonction des mots-clés. L'année 2000 voit le trafic journalier du site dépasser les 100 millions de requêtes, ce qui représente plus de 1000 requêtes/seconde en moyenne. Par son succès et sa croissance exponentielle, l'entreprise devient un phénomène mondial de presse.

L'année 2001 s'achève par une conquête physique du monde et par l'annonce de la 3 milliardième page indexée. Le 4 septembre 2001, Google obtient la validation de son brevet concernant PageRank.

Le moteur de recherche continue ainsi sa croissance, est décliné en plus de 100 langues en 2004 et 150 de nos jours. Aujourd'hui Google est le premier moteur de recherche sur Internet, que 80 % d'internautes américains utilisent contre seulement 35 % de Chinois, qui préfèrent l'outil chinois Baidu.

C'est à partir de 2002 que l'entreprise diversifie son activité, basée jusqu'alors sur son moteur de

4 Un produit en période de test bêta est généralement soumis à un nombre important ou représentatif de personnes : les bêta-testeurs. Ils peuvent être soit des employés de la société qui développe le logiciel, soit des bénévoles notamment dans le cas des logiciels libres. Ces personnes ont pour but d'utiliser le logiciel et de rapporter les problèmes rencontrés ainsi que leurs suggestions.



recherche. Apparaitront alors, parmi les plus connus, Gmail, Google Earth, Google Maps, Google Documents, Google Books, etc.

2.10.1.Fonctionnement du moteur de recherche Voici comment se passe une recherche avec Google :

1. L'internaute surfe sur Google.ch.2. Il tape des mots-clés.3. Sur certains navigateurs, Google complète certaines requêtes avec des termes de recherche

fréquents.4. L'internaute appuie sur la touche Entrée.5. Google ôte les mots non-significatif tels que les articles.6. La requête est dirigée vers le serveur Google le plus proche.7. Google recherche les informations correspondant à la requête parmi les milliards de pages

stockées sur des milliers d'ordinateurs de par le monde.8. Le gestionnaire de requête filtre les résultats pour proposer les plus pertinents. Il utilise plus

de 200 questions et une démarche proche de la logique humaine pour affiner les résultats.9. Dans certaines langues, le logiciel effectue des recherches de synonymes qui permettraient

de présenter des résultats encore plus pertinents.10. Un correcteur orthographique entre en action pour rechercher des liens en tenant compte

d'une éventuelle faute de frappe.11. Le logiciel recherche spam, virus et autres logiciels malveillants sur les pages.12. Google vérifie le type de fichier des contenus qu'il va lister.13. Les pages sont classées en fonction de leur PageRank (voir paragraphe suivant).14. Avant d'afficher les liens actifs, Google prépare les versions qu'il a déjà stockées sur ses

serveurs (et appelés « cache »), afin que l'internaute puisse au besoin les visionner.15. Le moteur prépare aussi une liste des Pages similaires, obtenue en utilisant diverses

logiques pour trouver des mots-clés en rapport avec ceux de la recherche initiale.16. La recherche que l'on a effectuée est devenue l'une des centaines de millions de pages

générées par Google quotidiennement.

Entre l'étape 5 et l'étape 16, il s'est écoulé moins d'une seconde !

2.10.2.PageRankLe PageRank ou PR est l'algorithme d'analyse des liens concourant au système de classement des

pages Web utilisé par le moteur de recherche Google pour déterminer l'ordre dans les résultats de recherche qu'il fournit. Ce système a été inventé par Larry Page, cofondateur de Google.

On attribue à chaque page un score compris entre 0 et 10, proportionnel au nombre de fois que passerait par cette page un internaute parcourant aléatoirement le graphe du Web en suivant les liens.



L'idée principale est que si une page A fait un lien vers une page B, alors c'est que la page A juge que la page B est suffisamment importante pour mériter d'être citée et d'être proposée aux visiteurs. Ce lien de A vers B augmente le PageRank de B.

Deux idées supplémentaires mais essentielles viennent la compléter :• l'augmentation de PageRank de la page B est d'autant plus importante que le PageRank de

la page A est élevé. En d'autres termes, il est bien plus efficace d'avoir un lien depuis la page d'accueil de Google que depuis une page du site de votre petit neveu.

• l'augmentation de PageRank de la page B est d'autant plus importante que la page A fait peu de liens. Autrement dit, si la page A juge qu'il n'y a qu'une page qui mérite un lien, alors il est normal que le PageRank de la page B augmente plus que dans le cas où de nombreuses pages obtiennent un lien.

Formulation mathématiqueAppelons A1, A2, ... An les n pages pointant vers une page B. Notons PR(Ak) le PageRank de la

page Ak, N(Ak) le nombre de liens sortants présents sur la page Ak et d un facteur compris entre 0 et 1, généralement fixé à 0.85.

Le PageRank de la page B se calcule à partir du PageRank de toutes les pages Ak de la manière suivante :

PRB=1 – d d⋅ PRA1N A1

PRA2N A2

PR AnN An

Cette formule est à la fois simple et compliquée. Simple parce qu'elle ne contient que des fractions, compliquée parce qu'elle est récursive : pour calculer le PageRank d'une page, il faut avoir calculé celui de toutes les pages pointant vers elle. Mais alors comment commencer ?

En fait c'est très simple, il suffit de commencer avec des valeurs arbitraires de PageRank (par exemple 1). Le choix de cette valeur n'a pas d'influence sur le résultat final à condition que toutes les pages commencent avec la même valeur. Une application de la formule permet de calculer un nouveau PageRank pour chaque page, plus proche de la réalité que la valeur par défaut que nous avons choisie au début.

Ensuite, nous recommençons à calculer les PageRank de toutes les pages en appliquant de nouveau la formule, mais en partant cette fois des valeurs que nous avons calculées précédemment. Après un certain nombre d'itérations, le système converge : les valeurs de PageRank de chaque page ne bougent plus entre deux itérations. En pratique la convergence est obtenue au bout de plusieurs dizaines d'itérations (tout dépend du nombre de pages considérées).

Le PageRank d'une page B ne dépend donc que de trois facteurs :• le nombre de pages Ak faisant un lien vers B, • le PageRank de chaque page Ak, • le nombre de liens sortants de chaque page Ak.

Il ne dépend ni du trafic, ni du nombre de fois qu'apparaît un mot-clé.

Exercice 2.2Exercice 2.2Vous avez créé un site web. Comment pouvez-vous améliorer le PageRank de la page d'accueil

(les moyens malhonnêtes sont permis) ?

Exercice 2.3Exercice 2.3Calculez le PageRank des pages web reliées selon le schéma ci-contre.

Prenez 1 comme PR initial.

Faites une itération à la main, puis écrivez un programme pour montrer la convergence.


A

B C D


2.11. Les réseaux pair-à-pair (peer to peer, P2P)Les systèmes pair-à-pair permettent à plusieurs ordinateurs de communiquer via un réseau, de

partager simplement des objets – des fichiers le plus souvent, mais également des flux multimédia continus (streaming), le calcul réparti, un service (comme la téléphonie avec Skype), etc. sur Internet.

Le pair-à-pair a permis une décentralisation des systèmes, auparavant basés sur quelques serveurs, en permettant à tous les ordinateurs de jouer le rôle de client et serveur (voir client-serveur). En particulier, les systèmes de partage de fichiers permettent de rendre les objets d'autant plus disponibles qu'ils sont populaires, et donc répliqués sur un grand nombre de nœuds. Cela permet alors de diminuer la charge (en nombre de requêtes) imposée aux nœuds partageant les fichiers populaires, ce qui facilite l'augmentation du nombre de nœuds et donc de fichiers dans le réseau.

Un réseau de type client-serveur. Un réseau pair-à-pair.

L'utilisation d'un système pair-à-pair nécessite pour chaque nœud l'utilisation d'un logiciel particulier. Ce logiciel, qui remplit alors à la fois les fonctions de client et de serveur, est parfois appelé « servent » (de la contraction de « serveur » et de « client », due à Gnutella), ou plus communément mais de façon réductrice, « client ». C'est là l'origine du terme pair (de l'anglais : peer) que l'on trouve dans pair-à-pair : les communications et les échanges se font entre des nœuds qui ont la même responsabilité dans le système.

Le modèle pair-à-pair va bien plus loin que les applications de partage de fichiers. Il permet en effet de décentraliser des services et de mettre à disposition des ressources dans un réseau. Tout nœud d'un réseau pair-à-pair peut alors proposer des objets et en obtenir sur le réseau. Les systèmes pair-à-pair permettent donc de faciliter le partage d'informations. Ils rendent aussi la censure ou les attaques légales ou pirates plus difficiles. Ces atouts font des systèmes pair-à-pair des outils de choix pour décentraliser des services qui doivent assurer une haute disponibilité tout en permettant de faibles coûts d'entretien. Toutefois, ces systèmes sont plus complexes à concevoir que les systèmes client-serveur.

ApplicationsChaque internaute est un pair du réseau et les ressources sont des fichiers. Chacun peut donc

partager ses fichiers et télécharger les fichiers des autres. Ces systèmes s'avèrent très efficaces y compris quand il s'agit d'échanger des données de gros volumes.

Une seconde application destinée au grand public ou à la recherche est la possibilité pour les internautes de mettre à disposition une partie de leur puissance de calcul. Les ordinateurs d'aujourd'hui sont tellement puissants que la majeure partie du temps, une grande partie de leur processeur est disponible pour effectuer des calculs. Le projet BOINC a saisi cette opportunité pour créer un gigantesque parc informatique réparti dans le monde afin d'utiliser cette immense puissance de calcul totale pour effectuer des calculs trop complexes pour être réalisé dans un laboratoire. Le projet BOINC demande donc au particulier de permettre l'usage de la puissance de calcul dont il n'a pas immédiatement besoin pour contribuer à la recherche sur le repliement de protéine (Folding@Home) et même à la recherche d'intelligence extra-terrestre (SETI@home).



2.12. L'informatique dans les nuagesL'« informatique dans les nuages » (cloud computing) est un concept apparu assez récemment,

mais dont les prémices remontent à quelques années, notamment à la technologie des grilles de calcul, utilisée pour le calcul scientifique. Le cloud computing fait référence à l'utilisation de la mémoire et des capacités de calcul des ordinateurs et des serveurs répartis dans le monde entier, et liés par un réseau, tel Internet. Cela signifie pour les utilisateurs, qu'ils accèdent à leurs applications et données sur des serveurs distants et non plus sur leurs propres machines. Dans ce concept, les utilisateurs n'ont plus à se soucier des aspects techniques (infrastructures, déploiement, mises à jour…). Les utilisateurs du nuage peuvent ainsi disposer d'une puissance informatique considérable.

L'intérêt du cloud computing est évident. Au lieu d'acheter cher des serveurs et des logiciels, qui ne sont pas utilisés à 100 %, les entreprises les louent et ne paient que pour l'usage qu'elles en font. Elles peuvent aussi, en quelques minutes, accéder à des capacités de stockage et de calcul supplémentaires, auxquelles elles n'auraient pas pu prétendre si elles avaient dû se les payer seules.

Il est fort probable que vous utilisez déjà le cloud computing sans vous en rendre compte : Gmail, Flickr ou Spotify sont des services auxquels vous avez accès via Internet et où vous stockez des données. C'est exactement le principe du cloud computing.

Avantages • L'accessibilité : vos données sont sur un serveur, consultables à n'importe moment et où

que vous soyez via une connexion Internet. • Partage et travail collaboratif : vous pouvez également partager vos ressources et

permettre ainsi un travail à plusieurs (pae exemple Google Docs).• Économique : votre prestataire gère complètement les aspects techniques du service et

des coûts engendrés. Pour une entreprise, cela se traduit par exemple par la disparition de mises à jour pour chaque poste, car réalisées côté serveur. Homogénéisation des versions et gain de temps.

Inconvénients• Connexion Internet obligatoire : sans celle-ci, inutile d'espérer pouvoir accéder à vos

ressources. C'est un réel frein lorsqu'on sait qu'en pleine campagne par exemple, le Wi-Fi devient rare et la 3G difficile à capter.

• Transportabilité des données : vos données sont-elles « prisonnières » du service auxquelles elles sont liées ? Comment récupérer nos données en cas de fermeture d'un service ?

• Sécurité et intégrité des données : le sujet est loin d'être simple et mérite des études approfondies. En regroupant vos ressources sur Internet vous perdez, une partie du contrôle sur celles-ci. Dès lors que vos données, même chiffrées, transitent sur Internet, le risque de piratage est bien plus présent que sur une utilisation locale. Deux exemples récents de pertes de données utilisateurs en cloud computing prouvent que le sujet est encore préoccupant. Toutes les données (contacts, agenda, photos, etc) d'utilisateurs du téléphone Sidekick (de l'opérateur T-mobile) se sont envolées suite à une opération de maintenance ratée par Microsoft. Autre exemple, un service en ligne de sauvegardes, Carbonite, a perdu les données d'une cinquantaine de clients, à cause d'une défaillance matériel. Il est donc primordial de prendre conscience des limites que le cloud computing impose.

Les avis divergent sur l'intérêt du cloud computing. D'un côté, les révolutionnaires vénèrent le principe et voient le futur sur un petit nuage. Un avenir mutualisé et sans cesse connecté à la Toile. De l'autre, les méfiants qui le redoutent et font des inconvénients cités ci-dessus leur argumentaire d'anti-cloud. Trop risqué et trop fragile, ce n'est pas un concept viable.

Pour Richard Stallman, à l'origine du système d'exploitation libre GNU, l'informatique dans le nuage « est un piège », ses utilisateurs perdant le contrôle de leurs applications. Ce militant du logiciel libre y voit un concept publicitaire sans intérêt, rejoignant les critiques exprimées par Larry Ellison, fondateur d'Oracle, selon lequel il s'agit d'un phénomène de mode.



Sources[1] Wikipédia, « Ordinateur », <http://fr.wikipedia.org/wiki/Ordinateur>

[2] Comment ça marche, « Introduction à la notion de mémoire », <http://www.commentcamarche.net/contents/pc/memoire.php3>

[3] Comment ça marche, « BIOS », <http://www.commentcamarche.net/contents/pc/bios.php3>

[4] Comment ça marche, « Système d'exploitation », <http://www.commentcamarche.net/contents/systemes/sysintro.php3>

[5] Comment ça marche, « Disque dur », <http://www.commentcamarche.net/contents/pc/disque.php3>

[6] Interstices, « Internet, le conglomérat des réseaux », <http://interstices.info/internet>

[7] Wikipédia, « World wide web », <http://fr.wikipedia.org/wiki/World_Wide_Web>

[8] Comment ça marche No5, Novembre 2010, pp. 62-65

[9] Wikipédia, «Google», <http://fr.wikipedia.org/wiki/Google>

[10] Webrankinfo, « Description de l'algorithme du PageRank », <http://www.webrankinfo.com/dossiers/pagerank/introduction>

[11] Eisermann Michael, « L'algorithme PageRank de Google : une promenade sur la toile », <http://www.igt.uni-stuttgart.de/eiserm/enseignement/google-promenade.pdf>

[12] Wikipédia, « Pair à pair », <http://fr.wikipedia.org/wiki/Pair_à_pair>


http://fr.wikipedia.org/wiki/Pair_%C3%A0_pair

http://www.igt.uni-stuttgart.de/eiserm/enseignement/google-promenade.pdf

http://www.webrankinfo.com/dossiers/pagerank/introduction

http://fr.wikipedia.org/wiki/Google

http://fr.wikipedia.org/wiki/World_Wide_Web

http://interstices.info/jcms/c_15921/internet-le-conglomerat-des-reseaux

http://www.commentcamarche.net/contents/pc/disque.php3

http://www.commentcamarche.net/contents/systemes/sysintro.php3

http://www.commentcamarche.net/contents/pc/bios.php3

http://www.commentcamarche.net/contents/pc/memoire.php3

http://fr.wikipedia.org/wiki/Ordinateur


http://ow.ly/2xKdB

Chapitre 3Codage de l'information

3.1. VocabulaireQuelle que soit la nature de l'information traitée par un ordinateur (image, son, texte, vidéo), elle

l'est toujours sous la forme d'un ensemble de nombres écrits en base 2, par exemple 01001011.Le terme bit (b minuscule dans les notations) signifie « binary digit », c'est-à-dire 0 ou 1 en

numérotation binaire. Il s'agit de la plus petite unité d'information manipulable par une machine numérique. Il est possible de représenter physiquement cette information binaire par un signal électrique ou magnétique, qui, au-delà d'un certain seuil, correspond à la valeur 1.

L'octet (en anglais byte ou B majuscule dans les notations) est une unité d'information composée de 8 bits. Il permet par exemple de stocker un caractère comme une lettre ou un chiffre.

Une unité d'information composée de 16 bits est généralement appelée mot (en anglais word).Une unité d'information de 32 bits de longueur est appelée mot double (en anglais double word,

d'où l'appellation dword). Beaucoup d'informaticiens ont appris que 1 kilooctet valait 1024 octets. Or, depuis décembre

1998, l'organisme international IEC a statué sur la question1. Voici les unités standardisées :• Un kilooctet (ko) = 1000 octets • Un mégaoctet (Mo) = 106 octets • Un gigaoctet (Go) = 109 octets • Un téraoctet (To) = 1012 octets• Un pétaoctet (Po) = 1015 octets

3.2. Les bases décimale, binaire et hexadécimale

Nous utilisons le système décimal (base 10) dans nos activités quotidiennes. Ce système est basé sur dix symboles, de 0 à 9, avec une unité supérieure (dizaine, centaine, etc.) à chaque fois que dix

1 http://physics.nist.gov/cuu/Units/binary.html

Didier Müller 3-1 novembre 2011

http://ow.ly/2xKdB

http://physics.nist.gov/cuu/Units/binary.html

Codage de l'information

unités sont comptabilisées. C'est un système positionnel, c'est-à-dire que l'endroit où se trouve le symbole définit sa valeur. Ainsi, le 2 de 523 n'a pas la même valeur que le 2 de 132. En fait, 523 est l'abréviation de 5·102+2·101+3·100. On peut selon ce principe imaginer une infinité de systèmes numériques fondés sur des bases différentes.

En informatique, outre la base 10, on utilise très fréquemment le système binaire (base 2) puisque l'algèbre booléenne est à la base de l'électronique numérique. Deux symboles suffisent : 0 et 1.

On utilise aussi très souvent le système hexadécimal (base 16) du fait de sa simplicité d'utilisation et de représentation pour les mots machines (il est bien plus simple d'utilisation que le binaire). Il faut alors six symboles supplémentaires : A (qui représente le 10), B (11), C (12), D (13), E (14) et F (15)

Le tableau ci-dessous montre la représentation des nombres de 0 à 15 dans les bases 10, 2 et 16.

Décimal 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

Binaire 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111

Hexadécimal 0 1 2 3 4 5 6 7 8 9 A B C D E F

3.2.1. Conversion décimal - binaireConvertissons 01001101 en décimal à l'aide du schéma ci-dessous :

27 26 25 24 23 22 21 20

0 1 0 0 1 1 0 1

Le nombre en base 10 est 26 + 23 + 22 + 20 = 64 + 8 + 4 + 1 = 77. Allons maintenant dans l'autre sens et écrivons 77 en base 2. Il s'agit de faire une suite de

divisions euclidiennes par 2. Le résultat sera la juxtaposition des restes. Le schéma ci-dessous explique la méthode mieux qu'un long discours :

77 s'écrit donc en base 2 : 1001101. Si on l'écrit sur un octet, cela donne : 01001101.



3.2.2. Conversion hexadécimal - binairePour convertir un nombre binaire en hexadécimal, il suffit de faire des groupes de quatre bits (en

commençant depuis la droite). Par exemple, convertissons 1001101 :

Binaire 0100 1101

Pseudo-décimal 4 13

Hexadécimal 4 D

1001101 s'écrit donc en base 16 : 4D. Pour convertir d'hexadécimal en binaire, il suffit de lire ce tableau de bas en haut.

Exercice 3.1Exercice 3.1Donnez la méthode pour passer de la base décimale à la base hexadécimale (dans les deux sens).

Exercice 3.2Exercice 3.2Complétez le tableau ci-dessous. L'indice indique la base dans laquelle le nombre est écrit.

Bases

2 10 16

10010101102

200210

A1C416

Exercice 3.3Exercice 3.3Écrivez en Python un programme permettant de convertir un nombre d'une base de départ d vers

une base d'arrivée a (d et a compris entre 2 et 16).

3.3. Représentation des nombres entiers

3.3.1. Représentation d'un entier naturelUn entier naturel est un nombre entier positif ou nul. Le choix à faire (c'est-à-dire le nombre de

bits à utiliser) dépend de la fourchette des nombres que l'on désire utiliser. Pour coder des nombres entiers naturels compris entre 0 et 255, il nous suffira de 8 bits (un octet) car 28=256. D'une manière générale un codage sur n bits pourra permettre de représenter des nombres entiers naturels compris entre 0 et 2n-1.

Exemples : 9 = 000001012, 128 = 100000002, etc.

3.3.2. Représentation d'un entier relatifUn entier relatif est un entier pouvant être négatif. Il faut donc coder le nombre de telle façon que

l'on puisse savoir s'il s'agit d'un nombre positif ou d'un nombre négatif, et il faut de plus que les règles d'addition soient conservées. L'astuce consiste à utiliser un codage que l'on appelle complément à deux. Cette représentation permet d'effectuer les opérations arithmétiques usuelles naturellement.



• Un entier relatif positif ou nul sera représenté en binaire (base 2) comme un entier naturel, à la seule différence que le bit de poids fort (le bit situé à l'extrême gauche) représente le signe. Il faut donc s'assurer pour un entier positif ou nul qu'il est à zéro (0 correspond à un signe positif, 1 à un signe négatif). Ainsi, si on code un entier naturel sur 4 bits, le nombre le plus grand sera 0111 (c'est-à-dire 7 en base décimale).

• Sur 8 bits (1 octet), l'intervalle de codage est [−128, 127].• Sur 16 bits (2 octets), l'intervalle de codage est [−32768, 32767].• Sur 32 bits (4 octets), l'intervalle de codage est [−2147483648, 2147483647].

D'une manière générale le plus grand entier relatif positif codé sur n bits sera 2n−1−1.

• Un entier relatif négatif sera représenté grâce au codage en complément à deux.

Principe du complément à deux1. Écrire la valeur absolue du nombre en base 2. Le bit de poids fort doit être égal à 0.2. Inverser les bits : les 0 deviennent des 1 et vice versa. On fait ce qu'on appelle le

complément à un. 3. On ajoute 1 au résultat (les dépassements sont ignorés).

Cette opération correspond au calcul de 2n−|x|, où n est la longueur de la représentation et |x| la valeur absolue du nombre à coder.

Ainsi −1 s'écrit comme 256−1=255=111111112, pour les nombres sur 8 bits.

ExempleOn désire coder la valeur −19 sur 8 bits. Il suffit : 1. d'écrire 19 en binaire : 00010011 2. d'écrire son complément à 1 : 11101100 3. et d'ajouter 1 : 11101101

La représentation binaire de −19 sur 8 bits est donc 11101101. On remarquera qu'en additionnant un nombre et son complément à deux on obtient 0. En effet,

00010011 + 11101101 = 00000000 (avec une retenue de 1 qui est éliminée).

TrucPour transformer de tête un nombre binaire en son complément à deux, on parcourt le nombre de

droite à gauche en laissant inchangés les bits jusqu'au premier 1 (compris), puis on inverse tous les bits suivants. Prenons comme exemple le nombre 20 : 00010100.

1. On garde la partie à droite telle quelle : 000101002. On inverse la partie de gauche après le premier un : 11101100 3. Et voici −20 : 11101100

Le 4 juin 1996, une fusée Ariane 5 a explosé 40 secondes après l'allumage. La fusée et son chargement avaient coûté 500 millions de dollars. La commission d'enquête a rendu son rapport au bout de deux semaines. Il s'agissait d'une erreur de programmation dans le système inertiel de référence. À un moment donné, un nombre codé en virgule flottante sur 64 bits (qui représentait la vitesse horizontale de la fusée par rapport à la plate-forme de tir) était converti en un entier sur 16 bits. Malheureusement, le nombre en question était plus grand que 32768 (le plus grand entier que l'on peut coder sur 16 bits) et la conversion a été incorrecte.

Exercice 3.4 Exercice 3.41. Codez les entiers relatifs suivants sur 8 bits (16 si nécessaire) : 456, −1, −56, −5642.2. Que valent en base dix les trois entiers relatifs suivants :

0110110011101101 1010101010101010 ?



Exercice 3.5Exercice 3.5Expliquez ce rêve étrange (source de l'image : http://xkcd.com/571).

3.4. Représentation des nombres réelsEn base 10, l'expression 652,375 est une manière abrégée d'écrire :

6·102 + 5·101 + 2·100 + 3·10-1 + 7·10-2 + 5·10-3.Il en va de même pour la base 2. Ainsi, l'expression 110,101 signifie :

1·22 + 1·21 + 0·20 + 1·2-1 + 0·2-2 + 1·2-3.

3.4.1. Conversion de binaire en décimalOn peut ainsi facilement convertir un nombre réel de la base 2 vers la base 10. Par exemple : 110,1012 = 1·22 + 1·21 + 0·20 + 1·2-1 + 0·2-2 + 1·2-3 = 4 + 2 + 0,5 + 0,125 = 6,62510.

Exercice 3.6Exercice 3.6Transformez 0,01010101012 en base 10.Transformez 11100,100012 en base 10.

3.4.2. Conversion de décimal en binaireLe passage de base 10 en base 2 est plus subtil. Par exemple : convertissons 1234,347 en base 2.• La partie entière se transforme comme au § 3.2.1 : 123410 = 100110100102

• On transforme la partie décimale selon le schéma suivant :

0,347·2 = 0,694 0,347 = 0,0...0,694·2 = 1,388 0,347 = 0,01...0,388·2 = 0,766 0,347 = 0,010...0,766·2 = 1,552 0,347 = 0,0101...0,552·2 = 1,104 0.347 = 0,01011...0,104·2 = 0,208 0,347 = 0,010110...0,208·2 = 0,416 0,347 = 0,0101100...0,416·2 = 0,832 0,347 = 0,01011000...0,832·2 = 1,664 0,347 = 0,010110001...0,664·2 = 1,328 0,347 = 0,0101100011...0,328·2 = 0,656 0,347 = 0,01011000110...

On continue ainsi jusqu'à la précision désirée...Attention ! Un nombre à développement décimal fini en base 10 ne l'est pas forcément en base 2.

Exercice 3.7Exercice 3.7Transformez 0,562510 en base 2.Transformez 0,1510 en base 2.Transformer 12,910 en base 2.


http://xkcd.com/571


IEEE, que l'on peut prononcer « i 3 e » : Institute of Electrical and Electronics Engineers

3.4.2. La norme IEEE 754La norme IEEE 754 définit la façon de coder un nombre réel. Cette norme se propose de coder le

nombre sur 32 bits et définit trois composantes : • le signe est représenté par un seul bit, le bit de poids fort• l'exposant est codé sur les 8 bits consécutifs au signe • la mantisse (les bits situés après la virgule) sur les 23 bits restants

Certaines conditions sont toutefois à respecter pour les exposants : • l'exposant 00000000 est interdit.• l'exposant 11111111 est interdit. On s'en sert toutefois pour signaler des erreurs, on appelle

alors cette configuration du nombre NaN, ce qui signifie « Not a number ». • il faut rajouter 127 (01111111) à l'exposant pour une conversion de décimal vers un nombre

réel binaire. Les exposants peuvent ainsi aller de −254 à 255.

La formule d'expression des nombres réels est ainsi la suivante :

(−1)^S * 2^(E − 127) * (1 + F)

• S est le bit de signe et l'on comprend alors pourquoi 0 est positif (−1^0=1),• E est l'exposant auquel on doit bien ajouter 127 pour obtenir son équivalent codé,• F est la partie fractionnaire.

ExempleTraduisons en binaire, en utilisant la norme IEEE 754, le nombre −6,625.

• Codons d'abord la valeur absolue en binaire : 6,62510 = 110,10102

• Nous mettons ce nombre sous la forme : 1, partie fractionnaire110,1010 = 1,101010·22 (22 décale la virgule de 2 chiffres vers la droite)

• La partie fractionnaire étendue sur 23 bits est donc 101 0100 0000 0000 0000 0000.• Exposant = 127 + 2 = 12910 = 1000 00012

Signe Exposant Mantisse1 1 0 0 0 0 0 0 1 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

En hexadécimal : C0 D4 00 00.

Le 25 février 1991, pendant la Guerre du Golfe, une batterie américaine de missiles Patriot, à Dharan (Arabie Saoudite), a échoué dans l'interception d'un missile Scud irakien. Le Scud a frappé un baraquement de l'armée américaine et a tué 28 soldats. La commission d'enquête a conclu à un calcul incorrect du temps de parcours, dû à un problème d'arrondi. Les nombres étaient représentés en virgule fixe sur 24 bits. Le temps était compté par l'horloge interne du système en dixième de seconde. Malheureusement, 1/10 n'a pas d'écriture finie dans le système binaire : 1/10 = 0,1 (dans le système décimal) = 0,0001100110011001100110011... (dans le système binaire). L'ordinateur de bord arrondissait 1/10 à 24 chiffres, d'où une petite erreur dans le décompte du temps pour chaque 1/10 de seconde. Au moment de l'attaque, la batterie de missile Patriot était allumée depuis environ 100 heures, ce qui a entraîné une accumulation des erreurs d'arrondi de 0,34 s. Pendant ce temps, un missile Scud parcourt environ 500 m, ce qui explique que le Patriot soit passé à côté de sa cible.



3.5. Le code ASCIILa norme ASCII2 (on prononce généralement « aski ») établit une correspondance entre une

représentation binaire des caractères de l'alphabet latin et les symboles, les signes, qui constituent cet alphabet. Par exemple, le caractère a est associé à 1100001 (97) et A à 1000001 (65).

La norme ASCII permet ainsi à toutes sortes de machines de stocker, analyser et communiquer de l'information textuelle. En particulier, la quasi-totalité des ordinateurs personnels et des stations de travail utilisent l'encodage ASCII. Le code ASCII de base représentait les caractères sur 7 bits (c'est-à-dire 128 caractères possibles, de 0 à 127).

• Les codes 0 à 31 ne sont pas des caractères. On les appelle caractères de contrôle car ils permettent de faire des actions telles que :

• retour à la ligne (Carriage return) • bip sonore (Audible bell)

• Les codes 65 à 90 représentent les majuscules • Les codes 97 à 122 représentent les minuscules (il suffit de modifier le 6ème bit pour passer

de majuscules à minuscules, c'est-à-dire ajouter 32 au code ASCII en base décimale).

2 American Standard Code for Information Interchange



Le code ASCII a été mis au point pour la langue anglaise, il ne contient donc pas de caractères accentués, ni de caractères spécifiques à une langue. Le code ASCII a donc été étendu à 8 bits pour pouvoir coder plus de caractères (on parle d'ailleurs de code ASCII étendu...). Cette norme s'appelle ISO-8859 et se décline par exemple en ISO-8859-1 lorsqu'elle étend l'ASCII avec les caractères accentués d'Europe occidentale, et qui est souvent appelée Latin-1 ou Europe occidentale.

Il existe d'autres normes que l'ASCII, comme l'Unicode par exemple, qui présentent l'avantage de proposer une version unifiée des différents encodages de caractères complétant l'ASCII mais aussi de permettre l'encodage de caractères autres que ceux de l'alphabet latin. Unicode définit des dizaines de milliers de codes, mais les 128 premiers restent compatibles avec ASCII.

Dans le codage UTF-8, chaque point de code est codé sur une suite d'un à quatre octets. Il a été conçu pour être compatible avec certains logiciels originellement prévus pour traiter des caractères d'un seul octet.



Toutes ces normes différentes et leurs incompatibilités partielles sont la cause des problèmes que l'on rencontre parfois avec les caractères accentués. C'est pour cette raison qu'il vaut mieux, quand on écrit des courriels à l'étranger, n'utiliser que des caractères non accentués.

3.6. Codage des couleurs

3.6.1. Le système RVBIl existe plusieurs façons de décrire les couleurs en informatique. Nous

présentons ici une des plus utilisées : le codage RVB, qui est utilisé notamment dans les formats d'image JPEG et TIFF. Rouge vert bleu, abrégé RVB (ou RGB de l'anglais red, green, blue), est un format de codage des couleurs. Ces trois couleurs sont les couleurs primaires en synthèse additive. Elles correspondent en fait à peu près aux trois longueurs d'ondes auxquelles répondent les trois types de cônes de l'œil humain (voir trichromie). L'addition des trois donne du blanc pour l'œil humain. Elles sont utilisées en éclairage afin d'obtenir toutes les couleurs visibles par l'homme. Elles sont aujourd'hui utilisées en vidéo, pour l'affichage sur les

écrans, et dans les logiciels d'imagerie.C'est sur ce principe que fonctionnent les téléviseurs couleur. Si vous regardez un écran de

télévision couleur avec une loupe, vous allez voir apparaître des groupes de trois points lumineux : un rouge, un vert et un bleu. La combinaison de ces trois points donne un point lumineux (un pixel) d'une certaine couleur.

Le système RVB est une des façons de décrire une couleur en informatique. Ainsi le triplet {255, 255, 255} donnera du blanc, {255, 0, 0} un rouge pur, {100, 100, 100} un gris, etc. Le premier nombre donne la composante rouge, le deuxième la composante verte et le dernier la composante bleue.

3.6.2. Le système CMJNLa quadrichromie ou CMJN (cyan, magenta, jaune, noir ; en anglais CMYK, cyan, magenta,

yellow, key) est un procédé d'imprimerie permettant de reproduire un large spectre colorimétrique à partir des trois teintes de base (le cyan, le magenta et le jaune ou yellow en anglais) auxquelles on ajoute le noir (key en anglais). L'absence de ces trois composantes donne du blanc tandis que la somme des trois donne du noir. Toutefois, le noir obtenu par l'ajout des trois couleurs Cyan, Magenta et Jaune n'étant que partiellement noir en pratique (et coûtant cher), les imprimeurs rajoutent une composante d'encre noire.

Le système CMJN est utilisé pour l'impression, tandis que le système RVB est utilisé pour la lumière (écran, projecteurs, ...).

3.7. Formats d'imagesOn désigne sous le terme d'image numérique toute image acquise, créée, traitée ou stockée sous

forme binaire (suite de 0 et de 1).



3.7.1. Images matricielles (ou images bitmap)Elles sont composées, comme leur nom l'indique, d'une matrice (tableau) de points colorés. Dans

le cas des images à deux dimensions (le plus courant), les points sont appelés pixels. Ce type d'image s'adapte bien à l'affichage sur écran informatique ; il est en revanche peu adapté pour l'impression, car la résolution des écrans informatiques, généralement de 72 à 96 ppp (« points par pouce », en anglais dots per inch ou dpi) est bien inférieure à celle atteinte par les imprimantes, au moins 600 ppp aujourd'hui. L'image imprimée, si elle n'a pas une haute résolution, sera donc plus ou moins floue ou laissera apparaître des pixels carrés visibles.

Les formats d'images matricielles les plus courants sont jpeg, gif, png, tiff, bmp.

Définition et résolutionLa définition d'une image matricielle est donnée par le nombre de points la composant. En image

numérique, cela correspond au nombre de pixels qui composent l'image en hauteur (axe vertical) et en largeur (axe horizontal) : 200 pixels x 450 pixels par exemple.

La résolution d'une image matricielle est donnée par un nombre de pixels par unité de longueur (classiquement en ppp). Ce paramètre est défini lors de la numérisation (passage de l'image sous forme binaire), et dépend principalement des caractéristiques du matériel utilisé lors de la numérisation. Plus le nombre de pixels par unité de longueur de la structure à numériser est élevé, plus la quantité d'information qui décrit cette structure est importante et plus la résolution est élevée. La résolution d'une image numérique définit donc le degré de détail de l'image. Ainsi, plus la résolution est élevée, meilleure est la restitution. Cependant, pour une même dimension d'image, plus la résolution est élevée, plus le nombre de pixels composant l'image est grand. Le nombre de pixels est proportionnel au carré de la résolution, étant donné le caractère bidimensionnel de l'image : si la résolution est multipliée par deux, le nombre de pixels est multiplié par quatre. Augmenter la résolution peut entraîner des temps de visualisation et d'impression plus longs, et conduire à une taille trop importante du fichier contenant l'image et à de la place excessive occupée en mémoire.

3.7.2. Retouche d'imageRetoucher une image revient à modifier les valeurs de

certains pixels. On peut le faire localement (à un endroit bien précis de l'image) ou globalement. Dans ce dernier cas, on utilise un outil appelé « courbe tonale », qui ressemble au dessin ci-contre.

Sur l'abscisse, on lit les valeurs originales des pixels et sur l'ordonnée les valeurs après modifications. Sur le graphique ci-contre, tous les pixels de valeurs 100 prendront la valeur 200. Ils vont donc s'éclaircir. La diagonale grise est



la courbe où il n'y a aucune modification.En fait, il y a trois courbes tonales : une pour le rouge, une pour le vert et une pour le bleu. On les

modifie souvent simultanément de la même façon, mais on peut aussi les modifier séparément.

Changer la luminositéPour augmenter la luminosité, il suffit d'ajouter une valeur fixe à tous les niveaux.

Pour une valeur de + 96, tous les points de l'espace V' seront blancs.

Première conséquence : les points les plus noirs auront une valeur égale à 96 et il n'existera plus aucun point entre 0 et 96.

Deuxième conséquence : les points ayant une valeur supérieures à 160 deviendront des points parfaitement blancs, puisque la valeur maximale possible est 255. Il y a donc perte d'informations.

Pour diminuer la luminosité il faudra au contraire soustraire une valeur fixe à tous les niveaux.

Pour une valeur de -100, tous les points de l'espace V'' seront noirs.

Première conséquence : les points les plus blancs auront une valeur égale à 156 et il n'existera plus aucun point entre 156 et 255.

Deuxième conséquence : les points ayant une valeur comprise entre 0 et 100 deviendront noirs, puisque la valeur minimale est 0. Il y aura donc là aussi perte d'informations.

Pour éviter ces pertes d'informations, il faut que la courbe tonale rejoigne les axes tangentiellement, comme dans l'exemple ci-contre. Ainsi, aucun point de débordera des valeurs limites minimale (0) ou maximale (255). Il sera en particulier possible de revenir en arrière.



Exercice 3.8Exercice 3.8Dessinez la courbe qui permettra d'annuler les modifications faites par la courbe tonale ci-dessus.

Augmenter le contrastePour rendre une image plus contrastée, il faut assombrir les points foncés et éclaircir les points

clairs, par exemple comme dans la figure ci-dessous :

Les points de l'espace V '' seront noirs et ceux de l'espace V ' blancs.

Pour les mêmes raisons que précédemment, cette manière de faire va causer des pertes d'informations. Aussi faut-il adoucir la courbe :

Exercice 3.9Exercice 3.91. Dessinez une courbe tonale qui va diminuer le contraste.2. Dessinez une courbe tonale qui transformera une image couleur en une image composée de

pixels noirs et de pixels blancs uniquement.

Exercice 3.10 : Mini-photoshopExercice 3.10 : Mini-photoshopProgrammez en Python quelques manipulations simples d'images. Pour cela, allez sur la page

http://ow.ly/2PhBd et suivez les instructions.


http://ow.ly/2PhBd


3.7.3. Images vectoriellesLe principe des images vectorielles est de représenter les données de l'image par des formules

géométriques qui vont pouvoir être décrites d'un point de vue mathématique. Cela signifie qu'au lieu de mémoriser une mosaïque de points élémentaires, on stocke la succession d'opérations conduisant au tracé. Par exemple, un dessin peut être mémorisé par l'ordinateur comme « une droite tracée entre les points (x1, y1) et (x2, y2) », puis « un cercle tracé de centre (x3, y3) et de rayon 30 de couleur rouge ». C'est le processeur qui sera chargé de traduire ces formes en informations interprétables par la carte graphique.

L'avantage de ce type d'image est la possibilité de l'agrandir indéfiniment sans perdre la qualité initiale, ainsi qu'un faible encombrement.

L'usage de prédilection des images vectorielles concerne les schémas générés avec certains logiciels de DAO (Dessin Assisté par Ordinateur) comme AutoCAD. Ce type d'image est aussi utilisé pour les animations Flash.

Étant donné que les moyens de visualisation d'images actuels comme les moniteurs d'ordinateur reposent essentiellement sur des images matricielles, les descriptions vectorielles (Fichiers) doivent préalablement être converties en descriptions matricielles avant d'être affichées comme images.

Quelques formats d'images vectorielles : ai (Adobe Illustrator), eps (encapsulated postscript), pdf (portable document format), svg (scalable vector graphics), swf (flash).

3.8. StéganographieContrairement à la cryptographie, qui chiffre des messages de manière à les rendre

incompréhensibles, la stéganographie cache les messages dans un support, par exemple des images ou un texte qui semble anodin.

On peut cacher un texte dans une image numérique et cela de manière parfaitement invisible à l'œil nu. Cette technique s'appelle le tatouage (watermarking en anglais). Elle est utilisée notamment pour protéger des images par copyright, mais on peut aussi transmettre des messages cachés. Nous proposons ici une méthode simple, mais qui fonctionne seulement avec certains formats d'images. En effet, beaucoup de formats compressent les données et donc modifient les bits de l'image, ce qui a pour effet de détruire le message caché.

3.8.1 Description d'une image bitmapUne image bitmap peut être décrite comme un tableau de triplets. Chaque triplet donne la couleur

d'un pixel dans le système RVB. On aura, par exemple, pour une image large de 3 pixels et haute de 2 pixels :

{255, 255, 255} {153, 219, 5} {102, 0, 0} {32, 32, 54} {0, 203, 7} {250, 37, 2}

3.8.2. Représentation binaire du texteChaque caractère du texte à cacher sera représenté par son code ASCII étendu, écrit en base 2. Le

code ASCII de « A » est 65, ce qui donne en binaire, sur un octet : 01000001. Le texte complet sera donc une suite de 0 et de 1, chaque caractère utilisant 8 bits.

Remarque: Si l'on n'utilisait que les 26 lettres majuscules, 5 bits suffiraient (25 = 32).

3.8.3. Intégration du texte dans l'imageSi l'on enlève les accolades, on peut imaginer l'image comme une suite de nombres compris entre

0 et 255. Notre technique de camouflage consistera dire qu'un nombre pair correspond à un 0 du texte et qu'un nombre impair correspond à un 1. Il faudra donc modifier certains pixels de l'image, mais ces altérations seront invisibles à l'œil.

On va procéder ainsi : si le nombre du tableau de l'image a la parité que l'on veut, on le laisse inchangé. Si ce n'est pas le cas, on lui ajoute 1 (on soustraira 1 si la valeur de départ est 255, afin d'éviter les débordements).

Reprenons le tableau donné en exemple ci-dessus et camouflons-y la lettre « A » :



Tableau original 255 255 255 153 219 5 102 0 ...

Texte à cacher (A) 0 1 0 0 0 0 0 1 ...

Tableau modifié 254 255 254 154 220 6 102 1 ...

3.8.4. Récupération du texteLa récupération se fait en cinq étapes :

1. Récupérer le tableau décrivant l'image. 2. Remplacer un nombre pair par 0, un nombre impair par 1. 3. Grouper les bits par groupes de 8. 4. Convertir chaque octet en nombre décimal. 5. Écrire les caractères correspondant aux codes ASCII obtenus.

Exercice 3.11Exercice 3.11Programmez en Python cette méthode pour cacher un texte dans une image. Pour cela, allez sur

la page http://ow.ly/4ermb et suivez les instructions.

3.9. Codes correcteurs d'erreursUn code correcteur est une technique de codage basée sur la redondance. Elle est destinée à

corriger les erreurs de transmission d'un message sur une voie de communication peu fiable.La théorie des codes correcteurs ne se limite pas qu'aux communications classiques (radio, câble

coaxial, fibre optique, etc.) mais également aux supports de stockage comme les disques compacts, la mémoire RAM et d'autres applications où l'intégrité des données est importante.

Comment détecter et/ou corriger des erreurs ?On peut transmettre un nombre soit en chiffres, soit en lettres :

1. On envoie « 0324614103 ». S'il y a des erreurs de transmission, par exemple si je reçois « 0323614203 », je ne peux pas les détecter.

2. On envoie « zéro trente-deux quatre cent soixante et un quarante et un zéro trois ». S'il y a des erreurs de transmission, par exemple si je reçois « zérb trente-deu quate cent soixante en un quaranhe et on zéro tros », je suis capable de corriger les erreurs et de retrouver le bon numéro.

Dans le premier cas, l'information est la plus concise possible. Dans le deuxième cas au contraire, le message contient plus d'informations que nécessaire. C'est cette redondance qui permet la détection et la correction d'erreurs.

Pourquoi ces codes ?• Des canaux de transmission imparfaits entraînant des erreurs lors des échanges de données. • La probabilité d'erreur sur une ligne téléphonique est de 10-7 (cela peut même atteindre

10-4). Avec un taux d'erreur de 10-6 et une connexion à 1 Mo/s, en moyenne 8 bits erronés sont transmis chaque seconde...

Principe général• Chaque suite de bits à transmettre est augmentée par une autre suite de bits dite « de

redondance » ou « de contrôle ». • Pour chaque suite de k bits transmise, on ajoute r bits. On dit alors que l'on utilise un code

C(n, k) avec n = k + r . • À la réception, les bits ajoutés permettent d'effectuer des contrôles.


http://ow.ly/2PhBd


Un exemple : le code ISBNL'ISBN (International Standard Book Number) est un

numéro international qui permet d'identifier, de manière unique, chaque livre publié. Il est destiné à simplifier la gestion informatique des livres dans les bibliothèques, librairies, etc.

Le numéro ISBN-10 se compose de quatre segments, trois segments de longueur variable et un segment de longueur fixe, la longueur totale de l'ISBN comprend dix chiffres (le 1er janvier 2007, la longueur a été étendue à 13 chiffres en ajoutant un groupe initial de 3 chiffres).

Si les quatre segments d'un ancien code ISBN à 10 chiffres sont notés A - B - C - D :• A identifie un groupe de codes pour un pays, une zone géographique ou une zone de langue. • B identifie l'éditeur de la publication. • C correspond au numéro d'ordre de l'ouvrage chez l'éditeur. • D est un chiffre-clé calculé à partir des chiffres précédents et qui permet de vérifier qu'il n'y

a pas d'erreurs. Outre les chiffres de 0 à 9, cette clé de contrôle peut prendre la valeur X, qui représente le nombre 10.

Calcul du chiffre-clé d'un numéro ISBN-10• On attribue une pondération à chaque position (de 10 à 2 en allant en sens décroissant) et on

fait la somme des produits ainsi obtenus. • On conserve le reste de la division euclidienne de ce nombre par 11. La clé s'obtient en

retranchant ce nombre à 11. Si le reste de la division euclidienne est 0, la clé de contrôle n'est pas 11 (11 - 0 = 11) mais 0.

• De même, si le reste de la division euclidienne est 1, la clé de contrôle n'est pas 10 mais la lettre X.

Le nombre 11 étant premier, une erreur portant sur un chiffre entraînera automatiquement une incohérence du code de contrôle. La vérification du code de contrôle peut se faire en effectuant le même calcul sur le code ISBN complet, en appliquant la pondération 1 au dixième chiffre de la clé de contrôle (si ce chiffre-clé est X, on lui attribue la valeur 10) : la somme pondérée doit alors être un multiple de 11.

ExemplePour le numéro ISBN (à 9 chiffres) 2-35288-041, quelle est la clé de contrôle ?

Code ISBN 2 3 5 2 8 8 0 4 1

Pondération 10 9 8 7 6 5 4 3 2

Produit 20 27 40 14 48 40 0 12 2

La somme des produits est 203, dont le reste de la division euclidienne par 11 est 5.La clé de contrôle est donc 11 - 5 = 6. L'ISBN au complet est : 2-35288-041-6.

La vérification de la clé complète à 10 chiffres donne la somme pondérée 203 + 6 = 209, qui est bien un multiple de 11.

Richard Hamming (1915-1998)

3.9.1. La distance de HammingLa distance de Hamming doit son nom à Richard Hamming. Elle est décrite dans un article

fondateur pour la théorie des codes. Elle est utilisée en télécommunication pour compter le nombre de bits altérés dans la transmission d'un message d'une longueur donnée.

Exemple : la distance de Hamming entre 1011101 et 1001001 est 2 car deux bits sont différents.

Il est souhaitable d'avoir une certaine distance entre les mots envoyés, afin de détecter s'il y a eu une erreur de transmission. Par exemple, si l'on a trois messages à transmettre de trois bits, il vaut



mieux choisir les codages qui sont à distance 2 les uns des autres, par exemple 000, 110 et 101. En effet, si un seul bit est altéré, on recevra un message impossible. Par contre, en utilisant 000, 001 et 010, un bit altéré pourrait passer inaperçu.

3.9.2. Somme de contrôleLa somme de contrôle (en anglais « checksum ») est un cas particulier de contrôle par

redondance. Elle permet de détecter les erreurs, mais pas forcément de les corriger. Nous en avons déjà vu un exemple avec le code ISBN-10.

Le principe est d'ajouter aux données des éléments dépendant de ces dernières et simples à calculer. Cette redondance accompagne les données lors d'une transmission ou bien lors du stockage sur un support quelconque. Plus tard, il est possible de réaliser la même opération sur les données et de comparer le résultat à la somme de contrôle originale, et ainsi conclure sur la corruption potentielle du message.

Bit de paritéTransmettons sept bits auxquels viendra s'ajouter un bit de parité. On peut définir le bit de parité

comme étant égal à zéro si la somme des autres bits est paire et à un dans le cas contraire. On parle de parité paire. Si la somme des bits est impair, c'est qu'il y a eu une erreur de transmission.

Exemple : 1010001 (7 bits) devient 11010001 (8 bits)Cette approche permet de détecter les nombres d'erreurs impaires, mais un nombre pair d'erreurs

passera inaperçu.

3.9.3. Code de HammingUn code de Hamming permet la détection et la correction automatique d'une erreur si elle ne

porte que sur une lettre du message. Un code de Hamming est parfait, ce qui signifie que pour une longueur de code donnée, il n'existe pas d'autre code plus compact ayant la même capacité de correction. En ce sens, son rendement est maximal.

Structure d'un code de Hamming• les m bits du message à transmettre et les n bits de contrôle de parité. • longueur totale : 2n−1• longueur du message : m = (2n−1)−n • on parle de code x−y : x est la longueur totale du code (n+m) et y la longueur du message

(m)• les bits de contrôle de parité Ci sont en position 2i pour i = 0, 1, 2,... • les bits du message Dj occupe le reste du message.

7 6 5 4 3 2 1

D3 D2 D1 C2 D0 C1 C0

Structure d'un code de Hamming 7−4

Exemples de code de Hamming• un mot de code 7−4 a un coefficient d'efficacité de 4/7 = 57 % • un mot de code 15−11 a un coefficient d'efficacité de 11/15 = 73 % • un mot de code 31−26 a un coefficient d'efficacité de 26/31 = 83 %

Retrouver l'erreur dans un mot de HammingSi les bits de contrôle de parité C2, C1, C0 ont tous la bonne valeur, il n'y a pas d'erreurs ; sinon la

valeur des bits de contrôle indique la position de l'erreur entre 1 et 7. Le code de Hamming présenté ici ne permet de retrouver et corriger qu'une erreur.

Pour savoir quels bits vérifient chaque bit de contrôle de parité dans un code d Hamming, il faut construire le tableau ci-dessous :



On numérote les lignes de 1 à x=2n−1 dans la colonne de droite (prenons comme exemple x=7), puis on convertit chaque nombre en binaire et l'on écrit chaque bit dans les colonnes de gauche. On colorie de la couleur de Ci les nombres de droite s'il y a un 1 dans dans la colonne Ci . Par exemple, 5 sera coloré en vert et en rouge, car sur la ligne du 5, il y a un 1 dans les colonnes C2 et C0.

C2 C1 C0 décimal

0 0 1 1 •

0 1 0 2 •

0 1 1 3 • •

1 0 0 4 •

1 0 1 5 • •

1 1 0 6 • •

1 1 1 7 • • •

• C2 (en vert) colore les bits 4, 5, 6, 7. Ce sont les bits qu'il vérifie.• C1 (en bleu) vérifie les bits 2, 3, 6, 7.• C0 (en rouge) vérifie les bits 1, 3, 5, 7.• On constate que chaque bit de données est coloré d'une manière différente. Cela permettra

de retrouver la position d'une erreur.

Exemple d'un code de Hamming 7-4 On souhaite envoyer le message 1010. Complétons le mot de Hamming correspondant :

7 6 5 4 3 2 1

1 0 1 0

C0 vaut 0 pour pouvoir rendre pair 1+1+0 (les bits d'indices 7, 5, 3).C1 vaut 1 pour pouvoir rendre pair 1+0+0 (les bits d'indices 7, 6, 3).C2 vaut 0 pour pouvoir rendre pair 1+0+1 (les bits d'indices 7, 6, 5).

7 6 5 4 3 2 1

1 0 1 0 0 1 0

Imaginons que l'on reçoive le mot 0010010 (le bit de poids fort a été altéré).C0 a la mauvaise valeur, car 0+1+0+0 est impair, donc il y a une erreur en position 7, 5, 3 ou 1.C1 a la mauvaise valeur, car 0+0+0+1 est impair, donc il y a une erreur en position 7, 6, 3 ou 2.C2 a la mauvaise valeur, car 0+0+1+0 est impair, donc il y a une erreur en position 7, 6, 5 ou 4.Écrivons le nombre binaire C2C1C0 où Ci vaut 0 si le bit de contrôle Ci a la bonne valeur et 1

sinon. On obtient ici 111, ce qui correspond à 7 en binaire. Le bit erroné est le numéro 7.

Que se passe-t-il si c'est un des bits de contrôle qui est altéré ? Imaginons que l'on ait reçu 1010011 (cette fois-ci, c'est le bit de poids faible qui a été altéré).

C0 a la mauvaise valeur, car 1+1+0+1 est impair. Il y a une erreur en position 7, 5, 3 ou 1.C1 a la bonne valeur, car 1+0+0+1 est pair. Il n'y a pas d'erreur en position 7, 6, 3 et 2C2 a la bonne valeur, car 1+0+1+0 est pair. Il n'y a pas d'erreur en position 7, 6, 5 et 4.Ici, C2C1C0 vaut 001. Le bit erroné est donc le numéro 1.

Exercice 3.12Exercice 3.12Vous voulez envoyer le mot 1011. Quels bits de contrôle devez-vous lui adjoindre et quelle

séquence transmettrez-vous alors ?



Exercice 3.13Exercice 3.13Y a-t-il une erreur dans le mot suivant (Hamming 7−4) : 1101101 ?

Exercice 3.14Exercice 3.14Soit un mot de Hamming 15−11 suivant :

15 14 13 12 11 10 9 8 7 6 5 4 3 2 1

1 0 1 1 0 1 1 1 1 0 1 1 0 1 1

1. Quels sont les bits de contrôle de parité ?2. Quelles positions contrôle chacun de ces bits ?3. Quel est le message reçu ? 4. Est-ce que le message reçu correspond au message transmis ?

3.10. Les codes-barresUn code-barres est la représentation d'une donnée numérique ou alphanumérique sous forme d'un

symbole constitué de barres et d'espaces dont l'épaisseur varie en fonction des données ainsi codées. Il existe des milliers de différents codes-barres ; ceux-ci sont destinés à une lecture automatisée par un capteur électronique.

Lorsque ces barres sont remplacées par des petits carrés ou des points, on parle de code en deux dimensions.

3.10.1.Codes-barres EANLe numéro EAN (European Article Numbering) identifie des articles ou des unités logistiques de

façon unique, codé sous forme de codes-barres. L'EAN est composé de 8 ou 13 chiffres représentés sous forme de séquences de barres noires et blanches formant un code-barres. Ce type de code-barres se trouve sur la presque totalité de produits courants (alimentation, vêtements, droguerie, papeterie, électroménager, etc.). Le code est lu lors du passage aux caisses des commerces.

Il existe des codes EAN-8 des codes EAN-13, composés respectivement de 8 ou 13 chiffres :• les codes EAN-8 sont réservés à l'usage sur des produits de petite taille (paquets de

cigarettes par exemple) ; • les codes EAN-13 sont utilisés sur tous les autres produits.

Le système des codes EAN, comme tous les systèmes de codes-barres, fait appel à des notions d'arithmétique modulaire. Sa structure tient compte des contraintes physiques liées aux conditions de leur impression et de leur lecture. En effet, la reconnaissance d'un code-barres nécessite :

• de pouvoir séparer et mesurer les largeurs des barres, à des distances de lecture variable, sur différents types de capteurs et en l’absence de toute horloge ou mesure de référence,

• de pouvoir le faire en outre dans n'importe quel sens de lecture et quelles que soient les couleurs effectivement utilisées.

Structure du code EAN-13• Le caractère de Début codé 101 (1 = noir, 0 = blanc)• Le second caractère du Préfixe (6). Le premier

caractère du préfixe n'est pas codé.• Les cinq caractères du Numéro de Participant

(12345)• Le Séparateur Central est codé 01010• Les cinq caractères du Numéro d'Article (67890)• Le Check Digit (0)• Le caractère de Fin codé 101.



Les caractères situés à gauche du Séparateur Central du symbole EAN 13 utilisent deux jeux de codification nommés élément A et élément B. Ceux situés à droite utilisent le jeu de codification nommé élément C. Le premier caractère du préfixe détermine l'alternance des éléments A et B à utiliser pour le codage des 6 caractères situés à gauche du séparateur central.

Table de codage des caractères EAN-13Chacun des chiffres composant l’EAN-13 peut, selon sa position dans le code, avoir trois

représentations distinctes nommées. La table ci-dessous indique comment coder chaque caractère d'un EAN 13 selon qu'il se trouve à gauche ou à droite du Séparateur Central. Les caractères de gauche utilisant le Set A ou B en fonction de la valeur du premier caractère du Préfixe.

Chaque élément peut être représenté en binaire par une suite de 7 bits :• un X ou 1 correspondant à une barre élémentaire noire, • un _ ou 0 correspondant à une barre élémentaire blanche.

Voici les représentations des 10 chiffres comme éléments A, B ou C :

Les éléments ci-dessus peuvent aussi être représentés sous la forme équivalente suivante où seules les largeurs des quatre barres successives (décrites de gauche à droite) sont indiquées (les éléments A et C se distinguent uniquement par la couleur de la première barre) :

chiffre élt A ou C élt B0 3211 11231 2221 12222 2122 22123 1411 11414 1132 23115 1231 13216 1114 41117 1312 21318 1213 31219 3112 2113

2 : 2122 (A), 3 : 1411 (A), 4 : 2311 (B), 5 : 1231 (A), 6 : 4111 (B), 7 : 2131 (B), 8 : 1213 (C), 9 : 3112 (C), 1 : 2221 (C), 2 : 2122 (C), 4 : 1132 (C), 8 : 1213 (C).

Dans le code-barres ci-dessus, le préfixe commence par 1, ce qui donne l'alternance AABABB. Les autres alternances en fonction du premier chiffre du préfixe sont données ci-dessous.

1 AABABB 2 AABBAB 3 AABBBA

4 ABAABB 5 ABBAAB 6 ABBBAA

7 ABABAB 8 ABABBA 9 ABBABA

0 AAAAAA (UPC-A)



Remarques1. Les codages B et C d'un même chiffre (donc situés ci-dessus sur la même ligne du premier

tableau) sont toujours symétriques l'un de l'autre. • Il en résulte que si le code est lu à l'envers, un élément de type B apparaît comme

un élément de type C et un élément de type C apparaît de type B. • Par contre, un élément de type A lu à l'envers est incorrect. Il y a donc toujours au

moins un élément de type A dans le code afin de déterminer le sens de lecture : pour le code EAN-8 ce sont tous les éléments de gauche, et pour le code EAN-13, le deuxième élément est toujours de type A.

2. Le codage d'un même chiffre comme élément C est toujours le complément de son codage comme élément A (les 1 et les 0 sont permutées).

• Il en résulte que si un élément qui devrait être de type A est en fait de type C, c'est que les couleurs sont inversées : blanc → 1 et noir → 0

3. Il découle des remarques précédentes que le codage EAN permet de lire le code : • quel que soit le sens de lecture (c'est pourquoi on peut, à une caisse de

supermarché, présenter un produit dans n'importe quelle position) ; • quelle que soit la couleur d'impression du code-barres (blanc sur fond noir, ou noir

sur fond blanc par exemple).4. Le codage EAN peut permettre de différencier 10 caractères distincts (ici, ce sont les dix

chiffres de 0 à 9) ; en revanche, il ne pourrait pas servir à coder des caractères supplémentaires (donc pas de lettre).

Exercice 3.15Exercice 3.15Retrouvez les 12 chiffres codés avec ce code ENA-13 :

3.10.2.QR CodesLe code QR (ou QR code en anglais) est un code-barres en deux dimensions (ou code à matrice)

constitué de modules noirs disposés dans un carré à fond blanc. Ce cours contient un QR code à chaque début de chapitre. Le nom QR est l'acronyme de l'anglais Quick Response, car son contenu de données peut être décodé rapidement.

Le code QR a été créé par l'entreprise japonaise Denso-Wave en 1994 pour le suivi des pièces de voiture dans les usines de Toyota.

Les codes QR peuvent mémoriser des adresses web, du texte, des numéros de téléphone, des SMS ou autres types de données lisibles par les smartphones et les téléphones mobiles équipés d'une application de lecture (lecteur de code QR ou QR reader en anglais).

L'avantage du code QR est sa facilité et rapidité d'utilisation et de création. Pour lire un code QR,



Ce QR-Code dessiné dans le sable est tout à fait valide. Essayez de le scanner !

il suffit de lancer l'application de lecture et viser le code dans le mobile. De nombreuses pages Web offrent ces applications pour mobiles, généralement sans frais.

En ce qui concerne l'écriture, il y a plusieurs sites web qui permettent de générer librement les codes QR, par exemple http://qrcode.kaywa.com/.

Ils peuvent stocker jusqu'à 7089 caractères numériques, 4296 caractères alphanumériques ou 2953 octets. Par rapport au code-barres traditionnel qui ne peut stocker que de 10 à 13 caractères, ils ont l'avantage de pouvoir stocker beaucoup d'informations tout en étant petits et rapides à scanner.

Le code QR est défini comme un standard ISO (IEC18004).

Les cases noires et blanches servent à l'orientation du QR code. Grâce à ces trois carrés, l'image peut être lue dans tous les sens.

L'information est codée selon le système Reed-Solomon et stockée dans la partie jaune. Certains types de codes restent lisibles avec 30% de dégradation.

Dans la partie cyan se trouvent des informations sur le format.

David A. Huffman(1925-1999)

3.11. Codage de HuffmanLe codage de Huffman (1952) est une méthode de compression statistique de données qui permet

de réduire la longueur du codage d'un alphabet. C'est un code de longueur variable optimal, c'est-à-dire que la longueur moyenne d'un texte codé est minimale. On observe des réductions de taille de l'ordre de 20 à 90%.

Le principeLe principe de l'algorithme de Huffman consiste à recoder les octets rencontrés dans un ensemble

de données source avec des valeurs de longueur binaire variable.L'unité de traitement est ramenée au bit. Huffman propose de recoder les données qui ont une

occurrence très faible sur une longueur binaire supérieure à la moyenne, et recoder les données très fréquentes sur une longueur binaire très courte.

Ainsi, pour les données rares, nous perdons quelques bits regagnés pour les données répétitives.Par exemple, dans un fichier ASCII le « w » apparaissant 10 fois aura un code très long :

0101000001000. Ici la perte est de 40 bits (10 x 4 bits), car sans compression, il serait codé sur 8 bits au lieu de 12. Par contre, le caractère le plus fréquent comme le « e » avec 200 apparitions sera codé


http://qrcode.kaywa.com/


par 1. Le gain sera de 1400 bits (7 x 200 bits). On comprend l'intérêt d'une telle méthode.De plus, le codage de Huffman a une propriété de préfixe : une séquence binaire ne peut jamais

être à la fois représentative d'un élément codé et constituer le début du code d'un autre élément.Si un caractère est représenté par la combinaison binaire 100 alors la combinaison 10001 ne peut

être le code d'aucune autre information. Dans ce cas, l'algorithme de décodage interpréterait les 5 bits comme deux mots : 100-01. Cette caractéristique du codage de Huffman permet une codification à l'aide d'une structure d'arbre binaire :

MéthodeAu départ, chaque lettre a une étiquette correspondant à sa fréquence (ou sa probabilité)

d'apparition. Il y a autant d'arbres (à 1 sommet) que de lettres.L'algorithme choisit à chaque étape les deux arbres d'étiquettes minimales, soit x et y, et les

remplace par l'arbre formé de x et y et ayant comme étiquette la somme de l'étiquette de x et de l'étiquette de y.

La figure ci-dessous représente les étapes de la construction d'un code de Huffman pour l'alphabet source {A, B, C, D, E}, avec les fréquences F(A)=15, F(B)=7, F(C)=6, F(D)=6 et F(E)=5.

Le code d'une lettre est alors déterminé en suivant le chemin depuis la racine de l'arbre jusqu'à la

feuille associée à cette lettre en concaténant successivement un 0 ou un 1 selon que la branche suivie est à gauche ou à droite. Ainsi, sur la figure ci-dessus, A=0, B=100, C=101, D=110, E=111.

Par exemple, le mot « ABBE » serait codé 0100100111. Pour décoder, on lit simplement la chaîne de bits de gauche à droite. Le seul découpage possible, grâce à la propriété du préfixe, est 0-100-100-111.



Un exemple d'arbre obtenu avec la phrase « this is an example of a huffman tree »

Ce principe de compression est aussi utilisé dans le codage d'image TIFF (Tagged Image Format File) spécifié par Microsoft Corporation et Aldus Corporation.

Il existe des méthodes qui ne conservent pas exactement le contenu d'une image (méthodes non conservatives) mais dont la représentation visuelle reste correcte. Entre autres, il y a la méthode JPEG (Join Photographic Experts Group) qui utilise la compression de type Huffman pour coder les informations d'une image.

Malgré son ancienneté, cette méthode est toujours remise au goût du jour, et offre des performances appréciables.

Exercice 3.16Exercice 3.16Construisez un codage de Huffman du message « ceciestuncodagedehuffman » (on a supprimé

les espaces et la ponctuation pour simplifier la construction). Il y a plusieurs codages de Huffman possibles.

Vérifiez la propriété du préfixe.

Sources[1] Dumas, Roch, Tannier, Varrette, Théorie des codes : Compression, cryptage, correction, Dunod,

2006

[2] Martin B., Codage, cryptologie et applications, Presses Polytechniques et Universitaires Romandes (PPUR), 2004

[3] Comment ça marche, « Représentation des nombres entiers et réels », <http://www.commentcamarche.net/contents/base/representation.php3>

[4] Wikipédia, « International Book Standard Number », <http://fr.wikipedia.org/wiki/ISBN>

[5] Müller Didier, « Cacher un texte dans une image », <http://www.apprendre-en-ligne.net/crypto/images/texteimage.html>

[6] Duvallet Claude, « Les codes correcteurs et les codes détecteurs d'erreurs », <http://litis.univ-lehavre.fr/~duvallet/enseignements/Cours/LPRODA2I/UF9/LPRODA2I-TD2-UF9.pdf>

[7] Wikipédia, « Code-barres EAN », <http://fr.wikipedia.org/wiki/Code-barres_EAN>

[8] Wikipédia, « Codage de Huffman », <http://fr.wikipedia.org/wiki/Codage_de_Huffman>


http://fr.wikipedia.org/wiki/Codage_de_Huffman

http://fr.wikipedia.org/wiki/Codage_de_Huffman

http://fr.wikipedia.org/wiki/ISBN

http://litis.univ-lehavre.fr/~duvallet/enseignements/Cours/LPRODA2I/UF9/LPRODA2I-TD2-UF9.pdf

http://litis.univ-lehavre.fr/~duvallet/enseignements/Cours/LPRODA2I/UF9/LPRODA2I-TD2-UF9.pdf

http://fr.wikipedia.org/wiki/ISBN

http://www.commentcamarche.net/contents/base/representation.php3


http://ow.ly/2wYSZ

Chapitre 4Algèbre booléenne

George Boole(1815-1864)

4.1. L'algèbre de BooleL'algèbre de Boole, ou calcul booléen, est la partie des mathématiques qui s'intéresse aux

opérations et aux fonctions sur les variables logiques. Elle fut inventée par le mathématicien britannique George Boole. Aujourd'hui, l'algèbre de Boole trouve de nombreuses applications en informatique et dans la conception des circuits électroniques.

On appelle B l'ensemble constitué de deux éléments appelés valeurs de vérité {FAUX, VRAI}. Cet ensemble est aussi noté B = {0, 1}, notation que l'on utilisera désormais.

Sur cet ensemble on peut définir les lois ET et OU et une transformation appelée « complémentaire » (parfois « inversion » ou « contraire »).

ETElle est définie de la manière suivante : a ET b est VRAI si et seulement si a est VRAI et b est

VRAI. Cette loi est aussi notée :• a·b • a/\b (dans quelques notations algébriques, ou en APL)• a&b ou a&&b (Perl, C, PHP, ...) • a AND b (Ada, Pascal, Python, ...)

OUElle est définie de la manière suivante : a OU b est VRAI si et seulement si a est VRAI ou b est

VRAI, ou si a et b sont vrais. Cette loi est aussi notée :

• a+b • a\/b (dans quelques notations algébriques ou en APL)• a|b ou a||b (Perl, C, PHP, ...)• a OR b (Ada, Pascal, Python, ...)

NONLe contraire de « a » est VRAI si et seulement si a est FAUX. Le contraire de a est noté :

• a• ¬a• ~a (dans quelques notations algébriques ou en APL)• !a (C, C++...) • NOT a (ASM, Pascal, ...)

Didier Müller 4-1 mars 2011

http://ow.ly/2wYSZ

Algèbre booléenne

En électronique, une porte NON est plus communément appelée inverseur. Le cercle utilisé sur la représentation est appelé « bulle », et montre qu'une entrée ou une sortie est inversée.

4.2. Fonctions logiques et tables de véritéUne table de vérité est un tableau qui représente des entrées (en colonne) et des états binaires (0

et 1). Le résultat, exprimé lui aussi sous forme binaire, se lit dans la dernière colonne.

Symbole de la porte logique (voir § 4.4)

Opérationbooléenne Table de vérité

ET(AND) A · B

Entrées SortieA B A AND B0 0 00 1 01 0 01 1 1

OU(OR) A + B

Entrées SortieA B A OR B0 0 00 1 11 0 11 1 1

NON(NOT) A

Entrée SortieA NOT A0 11 0

NON-ET (NAND) A⋅B

Entrées SortieA B A NAND B0 0 10 1 11 0 11 1 0

NON-OU (NOR)

AB

Entrées SortieA B A NOR B0 0 10 1 01 0 01 1 0

OU exclusif (XOR)

A ⊕ B

= A⋅BA⋅B

Entrées SortieA B A XOR B0 0 00 1 11 0 11 1 0



Toutes ces propriétés peuvent être facilement démontrées à l'aide de tables de vérité.

Augustus de Morgan

(1806-1871)

Quelques propriétés utiles

AssociativitéComme avec les opérations habituelles, certaines parenthèses sont inutiles :

(a + b) + c = a + (b + c) = a + b + c

(a·b)·c = a·(b·c) = a·b·c

CommutativitéL'ordre est sans importance :

a + b = b + a

a·b = b·a

DistributivitéComme avec les opérations mathématiques habituelles, il est possible de distribuer :

a·(b + c) = a·b + a·c

Attention : comportement différent par rapport aux opérateurs + et · habituels :

a + (b·c) = (a + b)·(a + c)

Idempotencea + a + a + [...] + a = a

a·a·a·[...]·a = a

Élément neutrea + 0 = a

a·1 = a

Élément nul0·a = 0

1 + a = 1

Complémentaritéa = ¬(¬a)

a + a = 1

a · a = 0

Théorème de De Morgan

a⋅b=ab ab=a⋅b

PrioritéPour faciliter leur compréhension, il a été décidé que ces opérations seraient soumises aux

mêmes règles que les opérations mathématiques. La fonction ET (multiplication logique) est ainsi prioritaire par rapport à la fonction OU (somme logique) ; on peut, pour s'aider, placer des parenthèses dans les opérations.


Algèbre booléenne

Maurice Karnaugh(1924-)

La case de la ligne 10 et sur la colonne 01 correspond à la valeur de S pour laquelle A=1, B=0, C=0 et D=1.

4.3. Tables de KarnaughUne table de Karnaugh est une méthode inventée par Maurice Karnaugh en 1954 et qui sert à

simplifier des équations logiques ou à trouver l'équation logique correspondant à une table de vérité. La méthode utilisée est graphique. Elle fonctionne très bien avec 3 ou 4 variables, beaucoup

moins bien avec 5 ou 6 variables, et plus du tout au-delà !

4.3.1. PrincipeSoit la table de vérité de S suivante avec les variables A, B, C et D :

A B C D S

0 0 0 0 1

0 0 0 1 0

0 0 1 0 1

0 0 1 1 1

0 1 0 0 0

0 1 0 1 1

0 1 1 0 1

0 1 1 1 1

1 0 0 0 1

1 0 0 1 0

1 0 1 0 1

1 0 1 1 1

1 1 0 0 0

1 1 0 1 1

1 1 1 0 1

1 1 1 1 1

La table de Karnaugh correspondante se présente ainsi :

4.3.2. Méthode de recherche de l'équation de la table de vérité• Pour trouver une équation logique, il faut regrouper les valeurs de S égales à 1 dans des

rectangles ayant comme nombre de cases une puissance de 2 (16, 8, 4, 2 ou 1 cases).



• Les groupes formés doivent être les moins nombreux possibles, mais ils doivent englober tous les 1. On peut faire des chevauchements.

• On a intérêt à dessiner des rectangles les plus grands possibles. • On peut considérer cette table comme un tore : la dernière ligne est adjacente à la première

et la première colonne est adjacente à la dernière. On peut ainsi regrouper des 1 se trouvant à ces emplacements.

Pour les tables à 4 variables, il faut de préférence procéder dans l'ordre suivant :

1. les rectangles 8 cases, puis 2. les rectangles 4 cases, puis3. les rectangles 2 cases, et enfin 4. les cases uniques.

Dans l'exemple ci-contre : on peut former un rectangle de 8 cases (en bleu), puis un carré de 4 (en vert) et enfin on peut regrouper les deux 1 restants (en rouge).

Mise en équationLe rectangle bleu correspond à l'équation « C » car dans ces deux colonnes et dans ces deux

colonnes seulement, C est toujours égal à 1.Le carré vert correspond à l'équation « B et D » car dans ces cases et dans ces cases seulement

B=1 et C=1. L'équation du rectangle rouge est « B et Cet D » car dans ces deux cases, B=0, C=0 et D=0.

Seul A vaut une fois 1 et une fois 0.On fait ensuite la somme des trois équations : « S = C ou (B et D) ou B et Cet D », que l'on peut

aussi écrire sous forme de l'équation « S = C + B·D + B⋅C⋅D ».

Exercice 4.1Exercice 4.1Trouvez les équations des tables de vérité de S, T et U avec les variables A, B, C et D :

A B C D S T U0 0 0 0 0 1 00 0 0 1 0 1 10 0 1 0 0 0 10 0 1 1 0 1 10 1 0 0 0 0 00 1 0 1 1 1 10 1 1 0 1 1 00 1 1 1 1 1 01 0 0 0 0 0 01 0 0 1 1 1 11 0 1 0 0 1 11 0 1 1 1 1 11 1 0 0 0 1 01 1 0 1 0 1 11 1 1 0 1 1 01 1 1 1 1 1 0

Vérifiez ensuite vos formules à l'aide d'un programme Python.


Algèbre booléenne

Les circuits logiques ont été dessinés grâce au programme Logicly.http://logic.ly/

4.4. Circuits logiquesOn appelle circuit logique (ou circuit combinatoire) un assemblage de portes logiques reliées

entre elles pour schématiser une expression algébrique. Par exemple, l'expression algébrique S=AB⋅AC sera schématisée comme suit :

La porte NANDLa porte NAND est la plus simple à réaliser du point de vue technologique. Il est possible de

réaliser toutes les fonctions logiques en utilisant uniquement ce type de porte.

Porte NON Porte ET

Porte OU Porte OU exclusif

Exercice 4.2Exercice 4.2Reprenez les équations trouvées à l'exercice 4.1, simplifiez-les grâce aux propriétés des fonctions

logiques, puis construisez les circuits logiques correspondants.

Exercice 4.3Exercice 4.3Réalisez une porte XOR avec des portes AND, OR et NOT.

Exercice 4.4Exercice 4.4On a trois interrupteurs pouvant être en position 0 ou 1 et trois ampoules pouvant être allumées

ou éteintes. On veut créer un circuit logique où le nombre de lampes allumées correspond au nombre d'interrupteurs positionnés sur 1, mais on ne veut pas savoir quels interrupteurs le sont.

1. Établissez la table de vérité de ce problème. 2. Trouvez l'équation la plus simple possible de la table de vérité. 3. Dessinez le circuit logique correspondant.


http://logic.ly/


Exercice 4.5Exercice 4.5Soit le circuit ci-dessous :

1. Écrivez l'équation de ce circuit.2. Établissez la table de vérité de ce circuit.

Exercice 4.6Exercice 4.6A quoi sert ce circuit ? Indication : les quatre interrupteurs représentent un nombre en base 2.

Exercice 4.7Exercice 4.7Les afficheurs 7 segments sont un type d'afficheur numérique très présent sur les calculatrices et

les montres à affichage numérique : les caractères (des chiffres, bien que quelques lettres soient utilisées pour l'affichage hexadécimal) s'écrivent en allumant ou en éteignant des segments, au nombre de sept. Quand les 7 segments sont allumés, on obtient le chiffre 8.

Voici les 16 symboles représentés avec l'affichage à 7 segments :


Algèbre booléenne

Dans un afficheur 7 segments, les segments sont généralement désignés par les lettres allant de A à G (voir ci-dessous).

On dispose de 4 interrupteurs qui représenteront les 4 bits d'un nombre exprimé en base 2 et compris entre 0 et 15. On veut que ce nombre en base 2 s'affiche en base 16. Les sept segments seront symbolisés par des ampoules.

1. Établissez les tables de vérité de ce problème. 2. Trouvez les équations les plus simples possible des tables de vérité. 3. Dessinez le circuit logique correspondant.

Sources[1] Mange Daniel, Analyse et Synthèse des systèmes logiques, PPUR, 1995

[2] Wikipédia, « Portail de la logique », <http://fr.wikipedia.org/wiki/Portail:Logique>


http://fr.wikipedia.org/wiki/Portail:Logique


http://ow.ly/2xxkI

Chapitre 5Programmation et langages

La programmation consiste à créer une séquence d'instructions pour un ordinateur afin qu'il puisse résoudre un problème ou exécuter une tâche.

À partir de ce chapitre, on supposera que le lecteur maîtrise le langage Python 3.

5.1. Un peu d'histoireEn 1936, la publication de l'article fondateur de la science informatique On Computable

Numbers with an Application to the Entscheidungsproblem, par Alan Mathison Turing, allait donner le coup d'envoi à la création de l'ordinateur programmable. Il y présente sa machine de Turing, le premier calculateur universel programmable, et invente les concepts et les termes de programmation et de programme.

En 1948, Konrad Zuse publie un article sur son langage de programmation qu'il a développé entre 1943 et 1945 : le Plankalkül. Zuse le considère comme étant le premier langage de haut niveau.

C'est à partir des années 50 que l'on verra apparaître les premiers langages de programmation modernes. Voici les créateurs des langages les plus utilisés :

• John Backus, inventeur de Fortran (1954)• John McCarthy, inventeur de LISP (1958) • Grace Hopper, surnommée « la mère langage COBOL » (1959)• John George Kemeny, concepteur du BASIC (1963)• Dennis Ritchie et Ken Thompson, inventeurs du langage C (1972)• Niklaus Wirth inventeur de Pascal (1970) et Modula-2 (1977)• Bjarne Stroustrup, développeur de C++ (1985) • Guido van Rossum, créateur de Python (1991)• James Gosling et Patrick Naughton, créateurs de Java (1991).

5.1.1. Évolution des langages informatiquesOn distingue aujourd'hui cinq générations de langages.La première génération est le langage machine, ou code machine. On parle aussi de langage

natif. Il est composé d'instructions et de données à traiter codées en binaire. C'est le seul langage qu'un ordinateur peut traiter directement.

Voici à quoi peut ressembler un programme en langage machine :

A1 01 10 03 06 01 12 A3 01 14

Il s'agit de la représentation hexadécimale d'un programme permettant d'additionner les valeurs de deux cases mémoire et de stocker le résultat dans une troisième case. On voit immédiatement la difficulté d'un tel langage...


http://ow.ly/2xxkI/

Programmation et langages

La deuxième génération est le langage assembleur1 : le code devient lisible et compréhensible par un plus grand nombre d'initiés. Il existe en fait un langage assembleur par type de processeur.

Le programme précédent écrit en assembleur donnerait ceci :

MOV AX, [0110]ADD AX, [0112]MOV [0114], AX

Il reste utilisé dans le cadre d'optimisations, mais a été supplanté en popularité par les langages plus accessibles de troisième génération.

La troisième génération utilise une syntaxe proche de l'anglais. Proposés autour de 1960, ces langages ont permis un gain énorme en lisibilité et en productivité. Ils ne dépendent plus du processeur, comme c'était le cas des générations précédentes, mais d'un compilateur2 spécifique du processeur. L'idée de portabilité3 des programmes était lancée.

La plupart des langages de programmation actuels sont de troisième génération. On trouve dans cette catégorie tous les grands langages : Ada, Algol, Basic, Cobol, Eiffel, Fortran, C, C++, Java, Perl, Pascal, Python, Ruby, ... Cette génération couvre d'ailleurs tant de langages qu'elle est souvent subdivisée en catégories, selon le paradigme4 particulier des langages.

Les langages de quatrième génération, abrégés L4G, souvent associée à des bases de données, se situent un niveau au-dessus, en intégrant la gestion de l'interface utilisateur5 et en proposant un langage moins technique, plus proche de la syntaxe naturelle.

Ils sont conçus pour un travail spécifique : gestion de base de données (Microsoft Access, SQL), production graphique (Postscript), création d'interface (4D).

La cinquième génération de langages sont des langages destinés à résoudre des problèmes à l'aide de contraintes, et non d'algorithmes écrits. Ces langages reposent beaucoup sur la logique et sont particulièrement utilisés en intelligence artificielle. Parmi les plus connus, on trouve Prolog, dont voici un exemple :

frère_ou_soeur(X,Y) :- parent(Z,X), parent(Z,Y), X \= Y.parent(X,Y) :- père(X,Y).parent(X,Y) :- mère(X,Y).mère(trude, sally).père(tom, sally).père(tom, erica).père(mike, tom).

Il en résulte que la demande suivante est évaluée comme vraie :

?- frère_ou_soeur(sally, erica). oui.

Ce qui signifie que Sally et Erica sont sœurs. En effet, Sally et Erica ont le même père (Tom).

1 Pour s'initier à l'assembleur : www.commentcamarche.net/contents/asm/assembleur.php3

2 En pratique, un compilateur sert le plus souvent à traduire un code source écrit dans un langage de programmation en un autre langage, habituellement un langage assembleur ou un langage machine. Le premier compilateur, A-0 System, a été écrit en 1951 par Grace Hopper.

3 En informatique, la portabilité d'un programme est caractérisée par sa capacité à fonctionner plus ou moins facilement dans différents environnements d'exécution

4 Voir paragraphe 5.5

5 L'interface utilisateur définit les moyens et outils mis en œuvre pour qu'un humain puisse contrôler et communiquer avec une machine.


http://www.commentcamarche.net/contents/asm/assembleur.php3


Il existe environ 2500 langages de programmation, certains étant très généraux (C, Java), d'autres hyper-spécialisés.Par exemple, RobotProg permet de déplacer un robot virtuel, R est un langage pour la statistique, etc.

Par comparaison, on recense environ 6800 langues humaines parlées et/ou écrites de par le monde.

5.1.2. Quelques langages courants

Source de ce schéma : [1]

Le nom Ada a été choisi en l'honneur d'Ada Lovelace, qui est supposée avoir écrit le premier programme de l'histoire.La première version d'Ada remonte à 1983.

5.1.3. « Hello world ! »C'est dans un memorandum interne de Brian Kernighan, Programming in C : A tutorial, écrit en

1974 dans les laboratoires Bell, que l'on trouve la première version d'un mini-programme affichant à l'écran « Hello World! ». Voici comment cela s'écrit dans divers langages6 :

Adawith Ada.Text_IO; use Ada.Text_IO; procedure Bonjour is begin -- Bonjour Put("Hello world!"); end Bonjour;

6 Une liste plus complète est disponible sur Wikipédia : http://fr.wikipedia.org/wiki/Hello_world


http://fr.wikipedia.org/wiki/Hello_world


BASIC est un acronyme pour Beginner's All-purpose Symbolic Instruction Code.Il a été conçu à la base en 1963 par John George Kemeny et Thomas Eugene Kurtz.

Inventé au début des années 1970 avec UNIX, C est devenu un des langages les plus utilisés.

Bjarne Stroustrup a développé C++ au cours des années 1980. Il s'agissait d'améliorer le langage C.

Fortran (FORmula TRANslator) est utilisé dans les applications de calcul scientifique.

Java a été créé par Sun Microsystems, et présenté officiellement le 23 mai 1995.

JavaScript est un langage de programmation de scripts utilisé dans les pages web interactives .

Assembleur X86 sous DOScseg segment assume cs:cseg, ds:cseg org 100h main proc jmp debut mess db 'Hello world!$' debut: mov dx, offset mess mov ah, 9 int 21h ret main endp cseg ends end main

BASIC10 PRINT "Hello world!"20 END

C#include <stdio.h> int main()/* ou int argc, char *argv[] */{ printf("Hello world!\n"); return 0;}

C++#include <iostream> int main(){ std::cout << "Hello world!" << std::endl; return 0;}

FORTRAN 77PROGRAM BONJOURWRITE (*,*) 'Hello world!'END

Javapublic class HelloWorld { public static void main(String[] args) { System.out.println("Hello world!"); }}

Javascriptdocument.write("Hello world!");

Python 1 et 2print "Hello world!"

Python 3print("Hello world!")



5.2. La machine de TuringUne machine de Turing est une machine théorique, inventée par Alan Turing en 1936, pour

servir de modèle idéal lors d'un calcul mathématique. Ce modèle est toujours largement utilisé en informatique théorique, en particulier pour résoudre les problèmes de complexité algorithmique et de calculabilité.

Turing Machine par Tom DunneAmerican Scientist, Mars-Avril 2002

Une machine de Turing se compose des éléments suivants :

• Un « ruban » divisé en cases adjacentes. Chaque case contient un symbole parmi un alphabet fini. L'alphabet contient un symbole spécial « blanc » et un ou plusieurs autres symboles. Le ruban est de longueur infinie vers la gauche ou vers la droite (en d'autres termes, la machine doit toujours avoir assez de longueur de ruban pour son exécution). On considère que les cases non encore écrites du ruban contiennent le symbole « blanc ».

• Une « tête de lecture/écriture » qui peut lire et écrire les symboles sur le ruban, et se déplacer vers la gauche ou vers la droite du ruban.

• Un « registre d'état » qui mémorise l'état courant de la machine de Turing. Le nombre d'états possibles est toujours fini, et il existe un état spécial appelé « état de départ » qui est l'état initial de la machine avant son exécution.

• Une « table d'actions » qui indique à la machine quel symbole écrire, comment déplacer la tête de lecture (« G » pour une case vers la gauche, « D » pour une case vers la droite), et quel est le nouvel état, en fonction du symbole lu sur le ruban et de l'état courant de la machine. Si aucune action n'existe pour une combinaison donnée d'un symbole lu et d'un état courant, la machine s'arrête.

Les machines de Turing sont une abstraction des ordinateurs :

• Le ruban représente la mémoire de l'ordinateur. Ceci comprend la mémoire centrale ainsi que les mémoires externes telles les disques durs. Contrairement à un ordinateur, la mémoire d'une machine de Turing est infinie.

• La tête de lecture/écriture représente le bus qui relie le microprocesseur à la mémoire. Une autre différence entre une machine de Turing et un ordinateur est que l'ordinateur peut accéder à la mémoire de manière directe, alors que la tête de lecture de la machine de Turing ne se déplace que d'une position à la fois.

• Le registre d'états et la table d'actions représentent le microprocesseur. Le nombre d'états est fini comme dans la réalité.



ExempleLa machine de Turing qui suit possède un alphabet {0, 1}, 0 étant le « blanc ». On suppose que le

ruban contient une série de 1, et que la tête de lecture/écriture se trouve initialement au-dessus du 1 le plus à gauche. Cette machine a pour effet de doubler le nombre de 1, en intercalant un 0 entre les deux séries. Par exemple, « 111 » deviendra « 1110111 ». L'ensemble d'états possibles de la machine est {e1, e2, e3, e4, e5} et l'état initial est e1. La table d'actions est la suivante :

État courant Symbole lu Symbole écrit Mouvement Nouvel état

e10 (Arrêt)

1 0 Droite e2

e21 1 Droite e2

0 0 Droite e3

e31 1 Droite e3

0 1 Gauche e4

e41 1 Gauche e4

0 0 Gauche e5

e51 1 Gauche e5

0 1 Droite e1

L'exécution de cette machine pourrait être par exemple (la position de la tête de lecture/écriture sur le ruban est inscrite en caractères gras et rouges) :

Étape État Ruban1 e1 112 e2 013 e2 0104 e3 01005 e4 01016 e5 01017 e5 01018 e1 11019 e2 100110 e3 100111 e3 1001012 e4 1001113 e4 1001114 e5 1001115 e1 1101116 (Arrêt)

Le comportement de cette machine peut être décrit comme une boucle :• Elle démarre son exécution dans l'état e1, remplace le premier 1 par un 0. • Puis elle utilise l'état e2 pour se déplacer vers la droite, en sautant les 1, et le premier 0

qu'elle rencontre. • L'état e3 est alors utilisé pour sauter la séquence suivante de 1 (initialement aucun) et



remplacer le premier 0 rencontré par un 1. • e4 permet de revenir vers la gauche jusqu'à trouver un 0, et passer dans l'état e5. • e5 permet ensuite à nouveau de se déplacer vers la gauche jusqu'à trouver un 0, écrit au

départ par l'état e1. • La machine remplace alors ce 0 par un 1, se déplace d'une case vers la droite et passe à

nouveau dans l'état e1 pour une nouvelle itération de la boucle. Ce processus se répète jusqu'à ce que e1 tombe sur un 0 (c'est le 0 du milieu entre les deux

séquences de 1) ; à ce moment, la machine s'arrête.

Exercice 5.1Exercice 5.1Construisez les machines de Turing suivantes :1. Une machine qui écrit 0 1 0 1 0 1 0 ... sur un ruban blanc. 2. Une machine qui multiplie par 2 son entrée binaire écrite sur le ruban.3. Une machine qui ajoute 1 à son entrée binaire écrite sur le ruban.

Pour les questions 2 et 3, on suppose que la tête de lecture/écriture est positionnée sur le symbole le plus à gauche.

5.3. Pseudo-codeEn programmation, le pseudo-code est une façon de décrire un algorithme en respectant certaines

conventions, mais sans référence à un langage de programmation en particulier. L'écriture en pseudo-code permet de développer une démarche structurée, en « oubliant » temporairement la syntaxe rigide d'un langage de programmation.

5.3.1. ConventionsIl n'existe pas de convention universelle pour le pseudo-code. Afin de bien se comprendre dans la

suite de ce cours, nous adopterons celle décrite ci-dessous.

Nom de l'algorithmePar exemple : Calcul de la date de Pâques

Données d'entréesPar exemple : Année > 1582

Résultat en sortiePar exemple : Date de Pâques pour l'année donnée

Bloc tant que :TANT QUE condition FAIRE instruction ...FIN TANT QUE

Bloc répéter jusqu'à :REPETER instruction ...JUSQU'A condition

Bloc pour :POUR i ALLANT DE d À f FAIRE instruction ...FIN POUR



Bloc si :SI condition ALORS instruction-si-vrai ...SINON instruction-si-faux ...FIN SI

Tableau : A[i] : l'élément de rang i dans le tableau A, on suppose les tableaux numérotés à partir de 0.

Tableau multidimensionnel A[i,j] : Élément en ligne i et en colonne j du tableau A.

Chaine de caractères : "string" (entre guillemets)

Affectation :a := 10

Fonction :FONCTION nom(paramètres) instruction ... RETOURNER résultat

Procédure :PROCEDURE nom(paramètres) instruction ... résultat

5.3.2. En pratique• Le pseudo-code doit être suffisamment précis pour que quelqu'un d'autre l'ayant lu sans

connaître l'algorithme soit capable de le coder. • L'objectif est d'avoir le pseudo-code le plus simple possible, afin de le coder facilement et

sans bug. Le pseudo-code d'un petit algorithme prend en général une douzaine de lignes. Pour un problème plus complexe, il faut compter jusqu'à 20 ou 25 lignes.

• Prévoyez assez de place pour faire tenir tout le pseudo-code sur une même page. • Lorsqu'on commence à écrire le pseudo-code, on ne sait pas encore précisément ce qui va

venir ensuite. Il est judicieux de laisser des lignes blanches régulièrement pour pouvoir ajouter des choses ensuite tout en gardant quelque chose de propre.

• Pour rendre compte visuellement des imbrications des boucles, indentez vers la droite le corps des boucles et des fonctions. Sur le papier, on peut ajouter de grandes barres verticales pour faire ressortir encore plus les différents blocs d'instructions.

5.3.3. Exemple de pseudo-codeAlgorithme : Tri d'une liste de nombresDonnée : Tableau A de n nombresRésultat : Tableau A de n nombres triés par ordre croissant



permut := 1TANT QUE permut = 1 FAIRE permut := 0 POUR i ALLANT DE 0 À n-1 FAIRE SI A[i] > A[i+1] ALORS echanger A[i] et A[i+1] permut := 1 FIN SI FIN POURFIN TANT QUE

5.4. Transformation du code sourceLe code source n'est (presque) jamais utilisable tel quel. Il est généralement écrit dans un langage

« de haut niveau », compréhensible pour l'homme, mais pas pour la machine. Il existe deux stratégies de traduction, ces deux stratégies étant parfois disponibles au sein du même langage.

• Le langage traduit les instructions au fur et à mesure qu'elles se présentent. Cela s'appelle la compilation à la volée, ou l'interprétation.

• Le langage commence par traduire l'ensemble du programme en langage machine, constituant ainsi un deuxième programme (un deuxième fichier) distinct physiquement et logiquement du premier. Ensuite, et ensuite seulement, il exécute ce second programme. Cela s'appelle la compilation.

5.4.1. CompilationCertains langages sont « compilés ». En toute généralité, la compilation est l'opération qui

consiste à transformer un langage source en un langage cible. Dans le cas d'un programme, le compilateur va transformer tout le texte représentant le code source du programme, en code compréhensible pour la machine, appelé code machine.

Dans le cas de langages compilés, ce qui est exécuté est le résultat de la compilation. Une fois effectuée, l'exécutable obtenu peut être utilisé sans le code source.

5.4.2. InterprétationD'autres langages ne nécessitent pas de phase spéciale de compilation. La méthode employée

pour exécuter le programme est alors différente. Le programme entier n'est jamais compilé. Chaque ligne de code est compilée « en temps réel » par un programme. On dit de ce programme qu'il interprète le code source. Par exemple, Python est un langage interprété.

Cependant, ce serait faux de dire que la compilation n'intervient pas. L'interprète produit le code machine, au fur et à mesure de l'exécution du programme, en compilant chaque ligne du code source.

5.4.3. Avantages, inconvénientsLes avantages généralement retenus pour l'utilisation de langages « compilés », est qu'ils sont

plus rapides à l'exécution que des langages interprétés, car l'interprète doit être lancé à chaque exécution du programme, ce qui mobilise systématiquement les ressources.

Les langages interprétés offrent en revanche une certaine portabilité, ainsi qu'une facilité pour l'écriture du code. En effet, il n'est pas nécessaire de passer par la phase de compilation pour tester le code source.



5.5. ParadigmesEn informatique, un paradigme est une une façon de programmer, un modèle qui oriente notre

manière de penser pour formuler et résoudre un problème.Certains langages sont conçus pour supporter un paradigme en particulier (Smalltalk et Java

supportent la programmation orientée objet, tandis que Haskell est conçu pour la programmation fonctionnelle), alors que d'autres supportent des paradigmes multiples (à l'image de C++, Common Lisp, OCaml, Python, Ruby ou Scheme).

5.5.1. Programmation impérativeC'est le paradigme le plus ancien. Les recettes de cuisine et les itinéraires routiers sont deux

exemples familiers qui s'apparentent à de la programmation impérative. La grande majorité des langages de programmation sont impératifs. Les opérations sont décrites en termes de séquences d'instructions exécutées par l'ordinateur pour modifier l'état du programme.

Niklaus Wirth

Edsger Wybe Dijkstra

5.5.2. Programmation structurée (ou procédurale)La programmation structurée constitue un sous-ensemble de la programmation impérative. C'est

un paradigme important de la programmation, apparu vers 1970. Elle dérive de travaux de Niklaus Wirth pour son Algol W et reçut son coup d'envoi avec l'article fondateur de Dijkstra dans Communications of the ACM intitulé GO TO statement considered harmful.

Elle est en effet célèbre pour son essai de suppression de l'instruction GOTO ou du moins pour la limitation de son usage.

La programmation structurée est possible dans n'importe quel langage de programmation procédural, mais certains, comme le Fortran IV, s'y prêtaient très mal. Vers 1970, la programmation structurée devint une technique populaire, et les langages de programmation procéduraux intégrèrent des mécanismes rendant aisée la programmation structurée. Parmi les langages de programmation les plus structurants, on trouve PL/I, Pascal et, plus tardivement pour les projets de très grande taille, Ada.

ExempleDans certains langages anciens comme le BASIC, les lignes de programmation portent des

numéros, et les lignes sont exécutées par la machine dans l'ordre de ces numéros. Dans tous ces langages, il existe une instruction de branchement, notée « aller à » en pseudo-code, instruction qui envoie directement le programme à la ligne spécifiée. Inversement, ce type de langage ne comporte pas d'instructions comme « Fin Tant Que », ou « Fin Si », qui ferment un bloc.

Prenons l'exemple d'une structure « Si … Alors … Sinon »

Programmation StructuréeSi condition Alors instructions 1Sinon instructions 2FinSi

Programmation non structurée1000 Si condition Alors Aller En 12001100 instruction 11110 etc.1120 etc.1190 Aller en 14001200 instruction 21210 etc.1220 etc.1400 suite de l'algorithme

Les programmeurs décomposent leur code en procédures ne dépassant guère 50 lignes, afin d'avoir le programme en entier sous leurs yeux.

Une procédure, aussi appelée routine, sous-routine, module ou fonction, contient une série d'étapes à réaliser. N'importe quelle procédure peut être appelée à n'importe quelle étape de l'exécution du programme, incluant d'autres procédures, voire la procédure elle-même (récursivité).



Il n'y a que des avantages à découper un programme en procédures :• on a la possibilité de réutiliser le même code à différents emplacements dans le programme

sans avoir à le retaper ; • il est plus simple de suivre l'évolution du programme (la programmation procédurale permet

de se passer d'instructions « GOTO ») ; • on crée un code plus modulaire et structuré ;• chaque programmeur peut développer son bout de code de son côté.

5.5.3. Programmation orientée objetLa programmation orientée objet (POO) ou programmation par objet, est un paradigme de

programmation informatique qui consiste en la définition et l'assemblage de « briques logicielles » appelées objets. Un objet représente un concept, une idée ou toute entité du monde physique, comme une voiture, une personne ou encore une page d'un livre. Le langage Simula-67 jette les prémisses de la programmation objet, résultat des travaux sur la mise au point de langages de simulation informatique dans les années 1960 dont s'inspira aussi la recherche sur l'intelligence artificielle dans les années 1970-80. Mais c'est réellement par et avec Smalltalk 72 puis Smalltalk 80, inspiré en partie par Simula, que la programmation par objets débute et que sont posés les concepts de base de celle-ci : objet, messages, encapsulation, polymorphisme, héritage, etc.

À partir des années 1980, commence l'effervescence des langages à objets : Objective C (début des années 1980), C++ (C with classes) en 1983, Eiffel en 1984, Common Lisp Object System dans les années 1980, etc. Les années 1990 voient l'âge d'or de l'extension de la programmation par objet dans les différents secteurs du développement logiciel.

Quelques langages à objets : Ada, Java, C#, Objective C, Eiffel, Python, C++, PHP, Smalltalk...

Nous y reviendrons plus en détails au paragraphe 5.7.

5.5.4. Programmation fonctionnelleLa programmation fonctionnelle est un paradigme de programmation qui considère le calcul en

tant qu'évaluation de fonctions mathématiques et rejette le changement d'état et la mutation des données. Elle souligne l'application des fonctions, contrairement au modèle de programmation impérative qui met en avant les changements d'état.

Le langage fonctionnel le plus ancien est Lisp, créé en 1958 par McCarthy. Lisp a donné naissance à des variantes telles que Scheme (1975) et Common Lisp (1984). Haskell (1987) est aussi un langage à paradigme fonctionnel. La programmation fonctionnelle s'affranchit de façon radicale des effets secondaires en interdisant toute opération d'affectation.

Le paradigme fonctionnel n'utilise pas de machine d'états pour décrire un programme, mais un emboîtement de « boîtes noires » que l'on peut imbriquer les unes dans les autres. Chaque boîte possédant plusieurs paramètres en entrée mais une seule sortie, elle ne peut sortir qu'une seule valeur possible pour chaque n-uplet de valeurs présentées en entrée. Ainsi, les fonctions n'introduisent pas d'effets de bord. Un programme est donc une application, au sens mathématique, qui ne donne qu'un seul résultat pour chaque ensemble de valeurs en entrée. Cette façon de penser, qui est très différente de la pensée habituelle en programmation impérative, est l'une des causes principales de la difficulté qu'ont les programmeurs formés aux langages impératifs pour aborder la programmation fonctionnelle. Cependant, elle ne pose généralement pas de difficultés particulières aux débutants qui n'ont jamais été exposés à des langages impératifs.

Exercice 5.2Exercice 5.2Expliquez cette description de Python, tirée de Wikipédia :

« Python est un langage de programmation interprété multi-paradigme. Il favorise la programmation impérative structurée, et orientée objet. »



5.6. Les notions principales de la programmationLa plupart des langages de programmation ont des caractéristiques communes que nous allons

passer rapidement en revue ici.

5.6.1. L'affectationUne affectation est une opération qui permet d'attribuer une valeur à une variable. Pour expliquer

ce qui se passe lors d'une affectation, il faut imaginer qu'il existe, dans un recoin de l'ordinateur, une case mémoire appelée x. L'instruction x=t consiste à remplir la case x avec la valeur de l'expression t. Si x contenait déjà une valeur, celle-ci est écrasée.

ExemplesAprès l'affectation x=3, la variable x contiendra la valeur 3.Après y=4+x, la variable y contiendra la valeur 7.

Affectation et comparaisonIl ne faut pas confondre l'affectation avec la comparaison. Par exemple, la comparaison x==3

permet de savoir si oui ou non la valeur de la variable x est 3. Dans la plupart des langages, on différencie ces deux opérations. En Python, l'affectation est exprimée par un « = », tandis que la comparaison est exprimée par « == ». D'autres langages (Pascal par exemple) utilisent respectivement les opérateurs « := » et « = ».

Incrémentation / décrémentationIl arrive fréquemment que l'on doive incrémenter (ou décrémenter) une variable, c'est-à-dire

augmenter (ou diminuer) sa valeur d'une ou plusieurs unités. Dans ce cas, on peut utiliser l'instruction x=x+17. Voici ce qui se passe : on prend la valeur contenue dans x, on y ajoute 1, puis on remet le nouveau résultat dans la variable x.

L'instruction x=x+1 est tellement fréquente qu'il existe souvent des raccourcis : x+=1 (Python) ou x++ (C, Mathematica).

5.6.2. Les testsUn test est une instruction du genre si...alors...sinon. La suite du programme dépendra du résultat

du test.

SI Test 1 ALORS Instruction 1SINON Instruction 2FIN SIInstruction 3

Par exemple, en Python, on aura :

if x>=10: x=x-20else: x=x+2

7 Remarquez bien que cette expression n'a mathématiquement aucun sens



Le même test en Java serait :

if (x>=10) x=x-20 else x=x+2

On peut enchaîner autant d'instructions « sinon si » que l'on veut : seule la première dont la condition sera vérifiée sera exécutée. On peut généralement associer une clause sinon qui ne sera exécutée que si aucune clause sinon si n'a été vérifiée.

SI Test 1 ALORS Instruction 1SINON SI Test 2 ALORS Instruction 2FIN SIInstruction 3

Par exemple, en Python 3 :

if x==0: print("x est nul")elif x<0: print("x est négatif")else: print("x est positif")

5.6.3. Les bouclesUne boucle est une structure de contrôle permettant de répéter une ou un ensemble d'instructions

plusieurs fois, tant qu'une condition est satisfaite.

Boucle « Tant que »

TANT QUE Test Instruction 1FIN TANT QUEInstruction 2

Par exemple, en Python 3, ce programme écrira tous les entiers de 0 à 9 :

x=0while x<10: print(x) x+=1

Le grand danger est ce qu'on appelle des boucles infinies, c'est-à-dire des boucles qui ne finissent jamais. Cela arrive quand la condition est toujours satisfaite, typiquement quand on oublie d'incrémenter un compteur. Voici une boucle qui écrira une infinité de 0, car on a oublié d'incrémenter x :

x=0while x<10: print(x)

Boucles imbriquéesIl est tout à fait possible, et parfois nécessaire, d'imbriquer une boucle dans une autre boucle. Par

exemple, imaginons que l'on veuille écrire toutes les heures et minutes d'une journée. Cela commencera par 0 heure 0 minute, 0 heure 1 minute, 0 heure 2 minutes, ..., 0 heure 59 minutes, 1



heure 0 minute, 1 heure 1 minute, ... On voit qu'une première boucle parcourra les heures, tandis que la deuxième parcourra les minutes, et que l'on incrémentera l'heure seulement quand 60 minutes seront passées. Voilà ce que cela donnera en Python 3 :

h=0while h<24: m=0 while m<60: print(h,"heure(s) ",m,"minute(s)") m+=1 h+=1

Si l'on veut ajouter les secondes, on imbriquera une troisième boucle :

h=0while h<24: m=0 while m<60: s=0 while s<60: print(h,"heure(s) ",m,"minute(s)",s,"seconde(s)") s+=1 m+=1 h+=1

Exercice 5.3Exercice 5.3Écrivez en Python un programme qui imprimera les tables de multiplication de 1 à 10.

Boucle « Jusqu'à ce que »Contrairement à un boucle « Tant que », une boucle « Jusqu'à ce que » exécute au moins une fois

les instructions comprises dans la boucles.

REPETER Instruction 1JUSQU'A CE QUE conditionInstruction 2

Ce type de boucle n'existe pas en Python, mais on le trouve en Pascal :

x=0;repeat x=x+1; print(x)until x=10;

CompteurUn compteur permet de réaliser une boucle associée à une variable entière qui sera incrémentée

(ou décrémentée) à chaque itération.

POUR compteur DE 0 A fin Instruction 1FIN POURInstruction 2

En BASIC :

FOR i = depart TO fin instruction NEXT i



En Pascal :

for i := depart to fin do instruction;

En C :

ItérateurUn itérateur est un objet qui permet de réaliser une boucle parcourant tous les éléments contenus

dans une structure de données (par exemple une liste).

POUR CHAQUE valeur DANS collection Instruction 1FIN POUR CHAQUEInstruction 2

Exemple en Python :

for animal in ["chat", "chien", "poule"] : print(animal)

5.6.4. Les sous-programmesUn sous-programme est un ensemble d'instructions pouvant être appelé depuis plusieurs endroits

du programme. Les sous-programmes sont utilisés pour améliorer la structure du programme et sa lisibilité. Ces constructions ajoutent la notion de passage de paramètres et aussi la notion de variables locales qui évite que le sous-programme ait un effet de bord sur la routine appelante.

Une fonction peut d'une part effectuer une action (par exemple afficher un résultat), et d'autre part retourner une valeur. Une fonction qui ne renvoie pas de valeur est appelée une procédure.

Portée d'une variableEn Python, une variable définie au moment où elle est affectée d'une valeur. Une variable définie

dans le programme principal est visible de l'intérieur des fonctions, mais une variable définie dans une fonction n'est pas visible de l'extérieur (à moins d'utiliser l'instruction global). Deux variables peuvent donc avoir le même nom mais être différentes selon l'endroit où elles sont définies.

Dans une fonction, Python utilise une variable définie localement. S'il elle n'est pas définie localement, Python recherche la variable au niveau global, mais dans ce cas, il n'est pas possible de modifier la variable globale.

Prenons un exemple en Python :def ecrire(): n = 3 print(n,end=' ')

n=5ecrire()print(n)



Tous ces exemples sont très mauvais du point de vue de la lisibilité. Il faut éviter d'écrire des programmes pareils ! Ils sont juste là pour préciser le concept de portée d'une variable.

Ce programme écrira 3 5. On voit bien que les deux n sont des variables différentes, puisque l'instruction n=3 n'a pas modifié la valeur de l'autre n. Le n de la deuxième ligne est une variable locale à la procédure ecrire, tandis que celui de la cinquième ligne est une variable locale.

Modifions légèrement ce programme :def ecrire(): n += 3 print(n,end=' ')

n=5ecrire()print(n)

Ce programme produira une erreur, car le n local dans la procédure écrire n'a pas été initialisé. Pour finir avec cet exemple, le programme ci-dessous donnera comme résultat 3 3. La ligne

global n signale que n est la variable globale initialisée dans le programme principal. Il ne s'agit donc plus d'une variable locale. Il n'y a là plus qu'une seule variable n.

def ecrire(): global n n = 3 print(n,end=' ')

n=5ecrire()print(n)

Passage de paramètresOn peut passer des paramètres à une procédure ou une fonction sous forme d'une liste de

paramètres formels entre parenthèses. A l'intérieur du corps de la procédure, les paramètres sont des variables locales.

Il ne faut pas redéclarer le nom des paramètres dans la section des déclarations locales. Voici un exemple en Pascal8, qui calcule xn (naïvement) :

var n : integer;

function puissance(x:real; n:integer) : real;var p:real;begin p:=1; while n>0 do begin p:=p*x; n:=n-1 end; puissance:=p end;

begin n:=3; writeln('Pi au cube =',puissance(3.14159,n)); writeln(n) (*la valeur de n n'a pas été modifiée*)end.

C'est la valeur du paramètre qui est passé à la procédure. Si la valeur est modifiée à l'intérieur de la procédure, la modification n'est pas répercutée à la sortie de la procédure. On appelle ce type de passage de paramètre un passage par valeur.

8 En Pascal, toutes les variables doivent être déclarées, ce qui n'est pas le cas en Python, où les variables « viennent au monde » en se voyant assigner une valeur et sont automatiquement détruites lorsqu'elles se retrouvent hors de portée.



Remarquez bien le mot-clef var entre les parenthèses qui fait toute la différence.

Dans certains langages, il est possible de passer des variables comme paramètres. On appelle cela un passage par variable ou passage par référence. Toute modification du paramètre dans la fonction appelée entraîne alors la modification de la variable passée en paramètre.

Voici un autre programme en Pascal, qui échange les valeurs de deux variables :

var x,y : real;

procedure echanger(var a,b:real)var aux:real;begin aux:=a; a:=b; b:=auxend;

begin x:=3; y:=4; echanger(x,y); writeln(' x=',x, ', y=',y)end.

Ce programme écrira x=4, y=3.Puisque la procédure attend des variables en paramètres, on ne peut pas appeler echanger avec

des valeurs (echanger(3,4) est interdit, car 3 et 4 ne sont pas des variables : on ne peut pas les modifier).

En Python, le passage des paramètres se fait toujours par référence, MAIS certains types sont « immutables », c'est-à-dire non modifiables. Les règles sont les suivantes :

• si un paramètre transmis à une fonction est une valeur immutable (les nombres et les chaînes de caractères), la fonction n'aura aucun moyen de modifier l'original. La valeur de départ est conservée ;

• si un paramètre est une valeur mutable (les listes par exemple), la fonction pourra modifier l'original, et avoir ainsi un effet de bord9 (désiré ou non).

Prenons un exemple (vicieux) :

def ecrire(x): x=5 print(x,end=' ')

x=0ecrire(x)print(x)

Le résultat sera 5 0, alors que l'on s'attendait plutôt à 5 5. Cela vient du fait que le type entier est immutable.

Par contre :

def ecrire(x): x[0]=5 # on modifie le 1er élément de la liste x print(x[0],end=' ')

x=[0,1,2,3,4]ecrire(x)print(x[0])

produira 5 5, car une liste n'est pas immuable. D'une manière générale, il vaut mieux éviter les effets de bords, afin d'avoir un programme plus lisible.

9 En informatique, une fonction est dite à effet de bord si elle modifie un état autre que sa valeur de retour.



5.6.5. La récursivitéEn informatique et en logique, une fonction qui s'appelle elle-même est dite récursive. Ce

concept est connu en art sous le nom de « mise en abyme ».

Exemple 1 : calcul de la factorielleRappel : n! = n·(n−1)·(n−2)· ... ·2·1. Cas particulier 0! = 1.

def factorielle(n): if n == 0 : return 1 else : return n * factorielle(n-1)

Le cas n=0 est appelé cas de base. Sans sa présence, l'algorithme ne peut pas se terminer.

Exemple 2 : écriture des digits d'un nombre entier positifdef ecrire(n): if n<0: print("erreur : nombre négatif") elif n<10: print(n,end=' ') else: ecrire(n//10) print(n%10,end=' ')

ecrire(453628)

Le résultat de ce programme sera 4 5 3 6 2 8.

Exemple 3 : élévation d'un entier x à une puissance ndef puissance(x,n): if n==0: return 1 elif n==1: return x elif n%2==0: return puissance(x*x, n//2) else: return puissance(x*x, n//2)*x



Exercice 5.4Exercice 5.4Le programme de l'exemple 3 calcule xn, d'une manière plus subtile que celle vue au paragraphe

5.6.4. Expliquez comment cela fonctionne et pourquoi c'est plus rapide.

La suite de Fibonacci ou les dangers de la récursivitéUtiliser une fonction récursive n'est pas toujours une bonne idée. Prenons la suite de Fibonacci :

1, 1, 2, 3, 5, 8, 13, 21, 34, ... Un terme est la somme des deux précédents. On va écrire deux fonctions (une récursive et une itérative) qui calculent le k-ième terme de cette suite, puis on comparera les temps de calcul.

import time

def fib1(n): # algorithme récursif if n==1 or n==2 : return 1 else : return fib1(n-1) + fib1(n-2)

def fib2(n): # algorithme itératif i=1 j=1 k=3 s=2 if n==1 or n==2 : return 1 else : while k<=n : s=i+j i=j j=s k+=1 return s

for k in range(5): print((k+1)*10) a=time.clock() fib1((k+1)*10) b=time.clock() print("récursif :", b-a) a=time.clock() fib2(k) b=time.clock() print("itératif :", b-a)

Voici une table des résultats (ces temps sont approximatifs et dépendent évidemment du processeur, mais ils mettent bien en évidence les problèmes de la récursivité) :

Fonction récursive (fib1) Fonction itérative (fib2)

k Temps (en secondes) Temps (en secondes)

10 7⋅10– 5 3⋅10– 6

20 3⋅10– 3 3⋅10– 6

30 0.5 3⋅10– 6

40 58 4⋅10– 6

50 7264 4⋅10– 6



5.7. La programmation orientée objetNous présentons ici les notions essentielles de la POO, avec des exemples en Python (voir aussi

chapitres 11 et 12 du livre de Gérard Swinnen Apprendre à programmer avec Python 3).

ClasseUne classe est un ensemble d'items qui ont une structure commune et un comportement commun,

par exemple une date, un étudiant, un véhicule, etc.class date : "Définition d'une date"

Objet / instanceUn objet est une instance d'une classe.Un objet est unique et identifiable avec un rôle bien défini. Ils sont persistants10 et changent

d'état.

noel2010 = date()

AttributUn attribut est une propriété observable des objets d'une classe. Dans notre exemple, une date est

définie par un jour, un mois et une année :noel2010.jour = 25noel2010.mois = 12noel2010.annee = 2009

MéthodeUne méthode est une opération qui peut changer la valeur des certains attributs d'un objet. Dans

l'exemple ci-dessous, il y a deux méthodes : la méthode constructeur __init__() permet d'initialiser la valeur d'un jour (par défaut le 1er janvier 2000) ; afficher() permet d'écrire une date au format jour/mois/année.

class date: "Définition d'une date" def __init__(self,j=1,m=1,a=2000): self.jour = j self.mois = m self.annee = a

def afficher(self): print(str(self.jour)+"/"+str(self.mois)+"/"+str(self.annee))

noel2010=date(25,12,2010)noel2010.afficher()

5.7.1. EncapsulationL'encapsulation est un mécanisme consistant à rassembler les données et les méthodes au sein

d'une structure en cachant l'implémentation de l'objet, c'est-à-dire en empêchant l'accès aux données par un autre moyen que les services proposés. L'encapsulation permet donc de garantir l'intégrité des données contenues dans l'objet.

L'exemple ci-dessous permet de trouver la date du lendemain, en étant sûr que le résultat sera une date valide. On ne pourra pas changer la valeur d'une date sans passer par la méthode incrementer().

10 Persistant : Un objet est créé à un certain moment, subit des changements d'états, et il est seulement détruit suite à une requête directe d'un utilisateur ou via un objet autorisé.



class date: "Définition d'une date" def __init__(self,j=1,m=1,a=2000): self.jour = j self.mois = m self.an = a

def afficher(self): print(str(self.jour)+"/"+str(self.mois)+"/"+str(self.an))

def incrementer(self): # donne la date du lendemain mois_31 = {1,3,5,7,8,10,12} self.jour += 1 if self.jour == 32 and (self.mois in mois_31): self.jour=1 self.mois+=1 if self.mois == 13: self.mois=1 self.an+=1 elif self.jour == 31 and (self.mois not in mois_31): self.jour=1 self.mois+=1 elif self.mois==2 : if self.jour == 30: self.jour=1 self.mois+=1 elif self.jour==29 and (self.an%4!=0 or self.an%100==0): if self.an%400!=0: self.jour=1 self.mois+=1

aujourdhui=date(1,1,2100)aujourdhui.afficher()i=0while i<370 : aujourdhui.incrementer() aujourdhui.afficher() i+=1

5.7.2. HéritageL'héritage est un principe propre à la programmation orientée objet, permettant de créer une

nouvelle classe à partir d'une classe existante. Le nom d' « héritage » vient du fait que la classe dérivée contient les attributs et les méthodes de sa superclasse. L'intérêt majeur de l'héritage est de pouvoir définir de nouveaux attributs et de nouvelles méthodes pour la classe dérivée, qui viennent s'ajouter à ceux et celles héritées.

Par ce moyen, on crée une hiérarchie de classes de plus en plus spécialisées. Cela a comme avantage majeur de ne pas avoir à repartir de zéro lorsque l'on veut spécialiser une classe existante. De cette manière il est possible d'acheter dans le commerce des librairies de classes, qui constituent une base, pouvant être spécialisées à loisir.

class Personnage: def __init__(self,nom,force,vie): self._nom = nom self._force = force self._vie = vie def getNom(self) : return self._nom def getForce(self) : return self._force def getVie(self) : return self._vie class Guerrier(Personnage): def __init__(self,nom,force,vie): Personnage.__init__(self,nom,force,vie) # héritage



class Mage(Personnage): def __init__(self,nom,force,vie,mana): Personnage.__init__(self,nom,force,vie) # héritage self._mana = mana def getMana(self) : return self._mana

Héritage multipleCertains langages orientés objet, tels que le C++ ou Python, permettent de faire de l'héritage

multiple, c'est-à-dire regrouper au sein d'une seule et même classe les attributs et méthodes de plusieurs classes.

Dans le design objet de tous les jours, l'héritage multiple est peu utilisé, car il introduit des dépendances généralement plus rigides que celles souhaitées.

5.7.3. PolymorphismeLe mot polymorphisme vient du grec et signifie « qui peut prendre plusieurs formes ». Cette

caractéristique est un des concepts essentiels de la programmation orientée objet. Alors que l'héritage concerne les classes (et leur hiérarchie), le polymorphisme est relatif aux méthodes des objets.

On distingue généralement trois types de polymorphisme : • le polymorphisme ad hoc (également appelé surcharge),• le polymorphisme paramétrique (également appelé généricité),• le polymorphisme d'héritage (également appelé redéfinition).

Le polymorphisme ad hocLe polymorphisme ad hoc permet de définir des opérateurs dont l'utilisation sera différente

selon le type des paramètres qui leur sont passés. Il est donc possible par exemple de surcharger l'opérateur + et de lui faire réaliser des actions différentes selon qu'il s'agit d'une opération entre deux entiers (addition : 3+4 = 7) ou entre deux chaînes de caractères (concaténation : parle+ment = parlement).

Le polymorphisme paramétriqueLe polymorphisme paramétrique représente la possibilité de définir plusieurs fonctions de même

nom mais possédant des paramètres différents (en nombre et/ou en type). Le polymorphisme paramétrique rend ainsi possible le choix automatique de la bonne méthode à adopter en fonction du type de donnée passée en paramètre.

Ainsi, on peut par exemple définir plusieurs méthodes homonymes addition() effectuant une somme de valeurs. Par exemple :

• La méthode addition(int, int) pourra retourner la somme de deux entiers.• La méthode addition(float, float) pourra retourner la somme de deux flottants. • La méthode addition(char, char) pourra définir la concaténation de deux caractères.

On appelle signature le nombre et le type (statique) des arguments d'une fonction. C'est donc la signature d'une méthode qui détermine laquelle sera appelée.

Le polymorphisme d'héritageLa possibilité de redéfinir une méthode dans des classes héritant d'une classe de base s'appelle la

spécialisation. Il est alors possible d'appeler la méthode d'un objet sans se soucier de son type intrinsèque : il s'agit du polymorphisme d'héritage. Ceci permet de faire abstraction des détails des classes spécialisées d'une famille d'objets, en les masquant par une interface commune (qui est la classe de base).

Reprenons notre exemple des personnages virtuels et ajoutons une méthode « attaquer ».



class Personnage: def __init__(self,nom,force,vie): self._nom = nom self._force = force self._vie = vie def getNom(self) : return self._nom def getForce(self) : return self._force def getVie(self) : return self._vie class Guerrier(Personnage): def __init__(self,nom,force,vie): Personnage.__init__(self,nom,force,vie) # héritage def attaquer(self,qui): print(self._nom,"pourfend",qui.getNom(),"de son épée")

class Mage(Personnage): def __init__(self,nom,force,vie,mana): Personnage.__init__(self,nom,force,vie) # héritage self._mana = mana def getMana(self) : return self._mana def attaquer(self,qui): print(self._nom,"ensorcelle",qui.getNom())

Merlin = Mage("Merlin",3,10,1)Duroc = Guerrier("Duroc",9,10)Merlin.attaquer(Duroc)Duroc.attaquer(Merlin)

Le résultat affiché sera :Merlin ensorcelle DurocDuroc pourfend Merlin de son épée

Exercice 5.5Exercice 5.5Créez une classe « Nain » où un personnage de ce type porte une attaque avec sa hache. Créez un

personnage de cette classe et nommez-le « Gimli ».

Exercice 5.6Exercice 5.6Imaginez d'autres races et sous-races (par exemple les elfes, les trolls, les trolls-cyclopes, etc.) et

implémentez un système pour simuler des combats entre ces personnages.

Les attributs vie, force, mana (et éventuellement d'autres que vous pourrez ajouter) seront modifiés selon les blessures infligées, dont la gravité sera déterminée aléatoirement. À vous de définir les règles ! Un personnage aura perdu le combat quand ses points de vie seront à zéro.

Organisez ensuite un tournoi où chaque personnage se battra en duel avec chacun des autres. Il y aura 10 personnages différents, pas forcément tous de race différente. Le tournoi sera donc composé de 45 combats.

Vous rendrez un petit rapport dans lequel vous décrirez votre système de jeu, les personnages avec leurs caractéristiques, ainsi que les résultats du tournoi.

Vous rendrez aussi votre programme Python complet sous forme électronique.

Que le tournoi commence !



Sources[1] Pixel, « Diagram and history of programming languages »,

<http://merd.sourceforge.net/pixel/language-study/diagram.html>

[2] Wikipédia, « Langages de programmation », <http://fr.wikipedia.org/wiki/Langage_de_programmation>

[3] Wikipédia, « Programmation informatique », <http://fr.wikipedia.org/wiki/Programmation>

[4] Wikipédia, « Machine de Turing », <http://fr.wikipedia.org/wiki/Machine_de_Turing>

[5] Wikipédia, « Paradigme (programmation) », <http://fr.wikipedia.org/wiki/Paradigme_(programmation)>

[6] Wikipédia, « Machine de Turing », <http://fr.wikipedia.org/wiki/Machine_de_Turing>

[7] Comment ça marche ?, « Programmation Orientée Objet », <http://www.commentcamarche.net/contents/poo/>

[8] Site du Zéro, « Le polymorphisme I », <http://www.siteduzero.com/tutoriel-3-63899-le-polymorphisme-i.html>


http://www.siteduzero.com/tutoriel-3-63899-le-polymorphisme-i.html

http://www.commentcamarche.net/contents/poo/

http://fr.wikipedia.org/wiki/Machine_de_Turing

http://fr.wikipedia.org/wiki/Paradigme_(programmation

http://fr.wikipedia.org/wiki/Machine_de_Turing

http://fr.wikipedia.org/wiki/Programmation

http://fr.wikipedia.org/wiki/Langage_de_programmation

http://merd.sourceforge.net/pixel/language-study/diagram.html


http://ow.ly/35Jlt

Chapitre 6Structures de données

avancéesUne structure de données est une organisation logique des données permettant de simplifier ou

d'accélérer leur traitement.

6.1. PileEn informatique, une pile (en anglais stack) est une structure de données fondée sur le principe

« dernier arrivé, premier sorti » (ou LIFO pour Last In, First Out), ce qui veut dire que les derniers éléments ajoutés à la pile seront les premiers à être récupérés.

Le fonctionnement est donc celui d'une pile d'assiettes : on ajoute des assiettes sur la pile, et on les récupère dans l'ordre inverse, en commençant par la dernière ajoutée.

PrimitivesVoici les primitives communément utilisées pour manipuler des piles :

• « empiler » : ajoute un élément sur la pile. Terme anglais correspondant : « Push ».• « dépiler » : enlève un élément de la pile et le renvoie. En anglais : « Pop »• « vide » : renvoie vrai si la pile est vide, faux sinon• « remplissage » : renvoie le nombre d'éléments dans la pile.

Applications• Dans un navigateur web, une pile sert à mémoriser les pages Web visitées. L'adresse de

chaque nouvelle page visitée est empilée et l'utilisateur dépile l'adresse de la page précédente en cliquant le bouton « Afficher la page précédente ».

• L'évaluation des expressions mathématiques en notation post-fixée (ou polonaise inverse) utilise une pile.

• La fonction « Annuler la frappe » (en anglais « Undo ») d'un traitement de texte

Didier Müller 6-1 décembre 2011

Structures de données avancées

mémorise les modifications apportées au texte dans une pile. • Un algorithme de recherche en profondeur utilise une pile pour mémoriser les nœuds

visités. • Les algorithmes récursifs admis par certains langages (LISP, Algol, Pascal, C, etc.)

utilisent implicitement une pile d'appel. Dans un langage non récursif (FORTRAN par exemple), on peut donc toujours simuler la récursion en créant les primitives de gestion d'une pile.

Exercice 6.1Exercice 6.1Implémentez en Python une classe « pile » avec ces quatre méthodes, ainsi qu'une méthode

« afficher » qui liste tous les éléments de la pile, du dernier entré au premier entré.

6.2. FileUne file (queue en anglais ) est une structure de données basée sur le principe « Premier entré,

premier sorti », en anglais FIFO (First In, First Out), ce qui veut dire que les premiers éléments ajoutés à la file seront les premiers à être récupérés. Le fonctionnement ressemble à une file d'attente : les premières personnes à arriver sont les premières personnes à sortir de la file.

PrimitivesVoici les primitives communément utilisées pour manipuler des files :

• « ajouter » : ajoute un élément dans la file. Terme anglais correspondant : « Enqueue »• « enlever » : renvoie le prochain élément de la file, et le retire de la file. Terme anglais

correspondant : « Dequeue »• « vide » : renvoie « vrai » si la file est vide, « faux » sinon• « remplissage » : renvoie le nombre d'éléments dans la file.

Applications• En général, on utilise des files pour mémoriser temporairement des transactions qui

doivent attendre pour être traitées. • Les serveurs d'impression, qui doivent traiter les requêtes dans l'ordre dans lequel elles

arrivent, et les insèrent dans une file d'attente (ou une queue). • Certains moteurs multitâches, dans un système d'exploitation, qui doivent accorder du

temps-machine à chaque tâche, sans en privilégier aucune. • Un algorithme de parcours en largeur utilise une file pour mémoriser les nœuds visités. • On utilise aussi des files our créer toutes sortes de mémoires tampons (en anglais

buffers).

Exercice 6.2Exercice 6.2Implémentez en Python une classe « file » avec ces quatre méthodes, ainsi qu'une méthode

« afficher » permettant de voir tous les éléments de la file, du premier entré au dernier entré.

Files à prioritésUne file à priorités est un type abstrait élémentaire sur laquelle on peut effectuer trois opérations :

• insérer un élément • supprimer le plus grand élément • tester si la file à priorités est vide ou pas

Les principales implémentations de ces files à priorités sont le tas (voir § 6.8), le tas binomial et le tas de Fibonacci.



Donald Knuth, professeur émérite à Stanford, auteur de l'ouvrage de référence sur l'algorithmique, en plusieurs volumes, intitulé « The Art of Computer Programming », considère les arbres comme « la structure la plus fondamentale de l'informatique ».

6.3. ArbresUn arbre est un graphe sans cycle, où des nœuds sont reliés par des arêtes. On distingue trois

sortes de nœuds :• les nœuds internes, qui ont des fils ;• les feuilles, qui n'ont pas de fils ;• la racine de l'arbre, qui est l'unique nœud ne possédant pas de père.

Traditionnellement, on dessine toujours la racine en haut et les feuilles en bas.

La profondeur d'un nœud est la distance, i.e. le nombre d'arêtes, de la racine au nœud. La hauteur d'un arbre est la plus grande profondeur d'une feuille de l'arbre. La taille d'un arbre est son nombre de nœuds (en comptant les feuilles ou non).

Les arbres peuvent être étiquetés. Dans ce cas, chaque nœud possède une étiquette, qui est en quelque sorte le « contenu » du nœud. L'étiquette peut être très simple (un nombre entier, par exemple) ou plus complexe : un objet, une instance d'une structure de données, etc.

Les arbres sont en fait rarement utilisés en tant que tels, mais de nombreux types d'arbres avec une structure plus restrictive existent et permettent alors des recherches rapides et efficaces. Nous en reparlerons bientôt.

6.3.1. Parcours

Parcours en largeurLe parcours en largeur correspond à un parcours par

niveau de nœuds de l'arbre. Un niveau est un ensemble de nœuds ou de feuilles situés à la même profondeur.

Ainsi, si l'arbre ci-contre est utilisé, le parcours sera A, B, C, D, E, F, G.

Parcours en profondeurLe parcours en profondeur est un parcours récursif sur un arbre. Il existe trois ordres pour cette

méthode de parcours. Le parcours en profondeur préfixé est le plus courant.

Parcours en profondeur préfixé

Dans ce mode de parcours, le nœud courant est traité avant le traitement des nœuds gauche et droit. Ainsi, si l'arbre précédent est utilisé, le parcours sera A, B, D, E, C, F, G.

Parcours en profondeur suffixé

Dans ce mode de parcours, le nœud courant est traité après le traitement des nœuds gauche et droit. Ainsi, si l'arbre précédent est utilisé, le parcours sera D, E, B, F, G, C, A. Ce mode de parcours correspond à une notation polonaise inverse, utilisée par les calculatrices HP.



Parcours en profondeur infixé

Dans ce mode de parcours, le nœud courant est traité entre le traitement des nœuds gauche et droit. Ainsi, si l'arbre précédent est utilisé, le parcours sera D, B, E, A, F, C puis G.

Exercice 6.3Exercice 6.3Parcourez l'arbre ci-dessous selon les quatre méthodes vues précédemment.

6.4. Arbres binairesDans un arbre binaire, chaque nœud possède au plus deux fils, habituellement appelés « gauche »

et « droit ». Du point de vue des fils, l'élément dont ils sont issus au niveau supérieur est logiquement appelé père.

6.4.1. Types d'arbres binaires• Un arbre binaire entier est un arbre dont tous les nœuds possèdent zéro ou deux fils. • Un arbre binaire parfait est un arbre binaire entier dans lequel toutes les feuilles sont à la

même hauteur. • Un arbre binaire complet comme étant un arbre binaire dans lequel les feuilles ont pour

profondeur n ou n−1 pour un n donné.



La fonction floor(x) retourne l'entier inférieur ou égal à x.

6.4.2. Méthodes pour stocker des arbres binaires

Structure à 3 nœudsLes arbres binaires peuvent être construits de différentes manières. Dans un langage avec

structures et pointeurs (ou références), les arbres binaires peuvent être conçus en ayant une structure à trois nœuds qui contiennent quelques données et des pointeurs vers son fils droit et son fils gauche. Parfois, il contient également un pointeur vers son unique parent. Si un nœud possède moins de deux fils, l'un des deux pointeurs peut être affecté de la valeur spéciale nulle.

L'arbre conservera un pointeur vers la racine, un pointeur vers le nœud courant (qui permet de simplifier l'ajout et la consultation) et éventuellement le nombre de nœuds du graphe.

Avantages• Conçu pour contenir un nombre variable de nœuds.• Pas de gaspillage de mémoire.

Inconvénients• Implémentation délicate à réaliser quand on est débutant en programmation.• Pas d'accès direct à un nœud de l'arbre.

TableauLes arbres binaires peuvent aussi être rangés dans des tableaux, et si l'arbre est un arbre binaire

complet, cette méthode ne gaspille pas de place, et la donnée structurée résultante est appelée un tas.Dans cet arrangement compact, un nœud a un indice i, et ses fils se trouvent aux indices 2i+1 et

2i+2, tandis que son père se trouve à l'indice floor((i−1)/2), s'il existe.

La racine (nœud 0) a pour fils les nœuds 1 et 2. Le nœud 1 a pour fils 3 et 4, etc.

Avantages• Implémentation facile à réaliser.• Possibilité d'accès direct à un nœud de l'arbre (un seul accès en mémoire).

Inconvénients• Conçu pour contenir un nombre fixe de nœuds.• Si l'arbre est profond mais contient peu de nœuds, il se produit un gaspillage important

de mémoire.



Notation O( ) :voir annexes

Complexité : voir annexes

6.5. Arbres binaires de rechercheUn arbre binaire de recherche (ABR) est un arbre binaire dans lequel chaque nœud possède une

étiquette, telle que chaque nœud du sous-arbre gauche ait une étiquette inférieure ou égale à celle du nœud considéré, et que chaque nœud du sous-arbre droit possède une étiquette supérieure ou égale à celle-ci (selon la mise en œuvre de l'ABR, on pourra interdire ou non des étiquettes de valeur égale). Les nœuds que l'on ajoute deviennent des feuilles de l'arbre.

6.5.1. RechercheLa recherche dans un arbre binaire d'un nœud ayant une étiquette particulière est un procédé

récursif. On commence par examiner la racine. Si l'étiquette de la racine est l'étiquette recherchée, l'algorithme se termine et renvoie la racine. Si l'étiquette cherchée est inférieure, alors elle est dans le sous-arbre gauche, sur lequel on effectue alors récursivement la recherche. De même, si l'étiquette recherchée est strictement supérieure à l'étiquette de la racine, la recherche continue sur le sous-arbre droit. Si on atteint une feuille dont l'étiquette n'est pas celle recherchée, on sait alors que cette étiquette n'est pas dans l'arbre.

Cette opération requiert un temps en O(log(n)) dans le cas moyen, mais O(n) dans le pire des cas où l'arbre est complètement déséquilibré où chaque père a un seul fils.

6.5.2. InsertionL'insertion d'un nœud commence par une recherche : on cherche l'étiquette du nœud à insérer ;

lorsqu'on arrive à une feuille, on ajoute le nœud comme fils de la feuille en comparant son étiquette à celle de la feuille : si elle est inférieure, le nouveau nœud sera à gauche ; sinon il sera à droite.

Exercice 6.4 Exercice 6.4Insérez dans l'arbre binaire de recherche ci-dessous les valeurs 11 et 5.

La complexité est O(log(n)) dans le cas moyen et O(n) dans le pire des cas.

6.5.3. SuppressionPlusieurs cas sont à considérer, une fois que le nœud à supprimer a été trouvé :

• Suppression d'une feuilleIl suffit de l'enlever de l'arbre étant donné qu'elle n'a pas de fils.



• Suppression d'un nœud avec un seul fils On l'enlève de l'arbre et on le remplace par son fils.

• Suppression d'un nœud avec deux filsSupposons que le nœud à supprimer soit appelé N (le nœud de valeur 7 dans le schéma ci-dessous). On le remplace alors par son successeur le plus proche, donc le nœud le plus à gauche du sous-arbre droit (ci-après, le nœud de valeur 9) ou son plus proche prédécesseur, donc le nœud le plus à droite du sous-arbre gauche (ci-dessous, le nœud de valeur 6).

Cela permet de garder une structure d'arbre binaire de recherche. Puis on applique à nouveau la procédure de suppression à N, qui est maintenant une feuille ou un nœud avec un seul fils.

Pour une implémentation efficace, il est déconseillé d'utiliser uniquement le successeur ou le prédécesseur car cela contribue à déséquilibrer l'arbre.

Dans tous les cas, cette opération requiert de parcourir l'arbre de la racine jusqu'à une feuille : le temps d'exécution est donc proportionnel à la profondeur de l'arbre qui vaut n dans le pire des cas, d'où une complexité maximale en O(n).

6.6. Rotations d'équilibragePour qu'un arbre soit efficace, il faut qu'il soit assez bien

équilibré (arbre ci-dessous). Même s'il l'est parfois au départ, il se dégradera au fur et à mesure des insertions et suppressions de nœuds (arbre de droite). On appelle cela la dégénérescence.



Il faut que ces fils existent, sinon l'opération est impossible !

Un arbre peut aussi être déséquilibré dès le départ, selon l'ordre dans lequel sont insérées les valeurs, le pire des cas survenant lorsque les valeurs sont insérées par ordre croissant ou décroissant : on obtient alors une liste.

Il faut donc le rééquilibrer constamment à l'aide de « rotations ».

6.6.1. Rotation simpleUne rotation est une modification locale d'un arbre binaire. Elle consiste à échanger un nœud

avec l'un de ses fils. Dans la rotation droite, un nœud devient le fils droit du nœud qui était son fils gauche. Dans la rotation gauche, un nœud devient le fils gauche du nœud qui était son fils droit. Les rotations gauches et droites sont inverses l'une de l'autre. Elles sont illustrées à la figure ci-dessous où les triangles désignent des sous-arbres non vides.

Les rotations ont la propriété de pouvoir être implémentées en temps constant, et de préserver l'ordre infixe. En d'autres termes, si A est un arbre binaire de recherche, tout arbre obtenu à partir de A par une suite de rotations gauche ou droite d'un sous-arbre de A reste un arbre binaire de recherche.

6.6.2. Rotation doublePour les arbres AVL, (voir § 6.7), on aura besoin d'une autre rotation de rééquilibrage, car la

rotation simple ne conserve pas une des propriétés de ce type d'arbre. On l'appellera rotation double, car elle est la succession de deux rotations simples.



La double rotation peut se réaliser par une suite de deux rotations simples : il suffit de faire une rotation gauche sur le nœud P, suivie d'une rotation droite sur le nœud R.

Exercice 6.5Exercice 6.5Sur l'arbre ci-dessous, effectuez :• une rotation droite sur le nœud « 3 »• une double rotation gauche sur le nœud « 8 »

6.7. Arbres AVLLa dénomination « arbre AVL » provient des noms de ses deux inventeurs russes, Georgy

Maximovich Adelson-Velsky et Evgenii Mikhailovich Landis, qui l'ont publié en 1962 sous le titre An algorithm for the organization of information.

Les arbres AVL ont été historiquement les premiers arbres binaires de recherche automati-quement équilibrés. Dans un arbre AVL, les hauteurs des deux sous-arbres d'un même nœud diffèrent



au plus de un. La recherche, l'insertion et la suppression sont toutes en O(log(n)) dans le pire des cas. L'insertion et la suppression nécessitent d'effectuer des rotations.

Le facteur d'équilibrage d'un nœud est la différence entre la hauteur de son sous-arbre droit et celle de son sous-arbre gauche. Un nœud dont le facteur d'équilibrage est 1, 0, ou -1 est considéré comme équilibré. Un nœud avec tout autre facteur est considéré comme déséquilibré et requiert un rééquilibrage. Le facteur d'équilibrage est soit déduit des hauteurs des sous-arbres, soit stocké dans chaque nœud de l'arbre (ce qui permet un gain de place, ce facteur pouvant être stocké sur deux bits, mais complexifie les opérations d'insertion et de suppression).

Les opérations de base d'un arbre AVL mettent en œuvre généralement les mêmes algorithmes que pour un arbre binaire de recherche, à ceci près qu'il faut ajouter des rotations de rééquilibrage vues au paragraphe 6.6.

6.7.1. InsertionL'insertion dans un arbre AVL se déroule en deux étapes :

1. tout d'abord, on insère le nœud exactement de la même manière que dans un arbre binaire de recherche ;

2. puis on remonte depuis le nœud inséré vers la racine en effectuant une rotation (simple ou double) sur chaque sous-arbre déséquilibré.

Soit A un arbre, G et D ses sous-arbres gauche et droit. On suppose que |h(G)−h(D)|=2. Si h(G)−h(D)=2, on fait une rotation droite, mais précédée d'une rotation gauche de G si h(g) < h(d) (on note g et d les sous-arbres gauche et droit de G). Si h(G)−h(D) = −2 on opère de façon symétrique.

On peut montrer en exercice qu'il suffit d'une seule rotation ou double rotation pour rééquilibrer un arbre AVL après une insertion.

La hauteur de l'arbre étant en O(log(n)), et les rotations étant à temps constant, l'insertion se fait finalement en O(log(n)).

Il est commode que la fonction d'insertion retourne une valeur représentant la différence entre la nouvelle hauteur (après l'insertion) et l'ancienne hauteur (avant l'insertion). Quand il peut y avoir un déséquilibre trop important entre les deux fils du nœud où l'on insère un nouvel élément, il faut recréer un équilibre par une rotation simple ou une rotation double.

6.7.2. SuppressionLa suppression dans un arbre AVL peut se faire par rotations successives du nœud à supprimer

jusqu'à une feuille (en choisissant ces rotations de sorte que l'arbre reste équilibré), et ensuite en supprimant cette feuille directement. La suppression se fait aussi en O(log(n)).

6.7.3. RechercheLa recherche dans un arbre AVL se déroule exactement comme pour un arbre binaire de

recherche, et comme la hauteur d'un arbre AVL est en O(log(n)), elle se fait donc en O(log(n)).



Exercice 6.6Exercice 6.6Observez sur l'applet du site compagnon comment insérer, supprimer et rechercher une valeur

dans un arbre AVL.

6.8. TasOn dit qu'un arbre binaire complet est ordonné en tas1 (on dit aussi parfois « monceau ») lorsque

la propriété suivante est vérifiée :

Pour tous les nœuds de l'arbre, étiquette(père) ≥ étiquette(fils).

Cette propriété implique que la plus grande étiquette est située à la racine du tas. Ils sont ainsi très utilisés pour implémenter les files à priorités2 car ils permettent des insertions en temps logarithmique et un accès direct au plus grand élément. L'efficacité des opérations effectuées sur des tas est très importante dans de nombreux algorithmes sur les graphes.

Le fait qu'un tas soit un arbre binaire complet permet de le représenter d'une manière intuitive par un tableau unidimensionnel. Dans un tableau indicé à partir de 0 : le père d'un nœud en position i a pour position, et donc les enfants d'un nœud en position i sont situés à 2i+1 pour le fils gauche et 2i+2 pour le fils droit (voir § 6.4.2).

6.8.1. PrimitivesUne caractéristique fondamentale de cette structure de données est que la propriété du tas peut

être restaurée efficacement après la modification d'un nœud. Si la valeur du nœud est augmentée et qu'elle devient de ce fait supérieure celle de son père, il suffit de l'échanger avec celle-ci, puis de continuer ce processus vers le haut jusqu'au rétablissement de la propriété du tas. Nous dirons que la valeur modifiée a été percolée jusqu'à sa nouvelle position.

Inversement, si la valeur du nœud est diminuée et qu'elle devient de ce fait inférieure à celle d'au moins un de ses fils, il suffit de l'échanger avec la plus grande des valeurs de ses fils, puis de continuer ce processus vers le bas jusqu'au rétablissement de la propriété du tas. Nous dirons que la valeur modifiée a été tamisée jusqu'à sa nouvelle position.

1 Heap en anglais2 Voir § 6.2. Le mot « file » est mal choisi, car une file de priorité ne ressemble pas à une file, ni par son aspect, ni par son comportement.



Plus formellement, la modification d'un nœud se fait par les algorithmes suivants :

PROCEDURE percoler(T[0..n-1], i)Données : tableau T, noeud iRésultat : T est de nouveau un task := iREPETER j := k SI j > 0 ET T[(j-1) div 2] < T[k] ALORS k := (j-1) div 2 echanger T[j] et T[k]JUSQU'A j = k

PROCEDURE tamiser(T[0..n-1], i) Données : tableau T, noeud iRésultat : T est de nouveau un task := iREPETER j := k (* recherche du plus grand fils du noeud j *) SI 2j+1 <= n-1 ET T[2j+1] > T[k] ALORS k := 2j+1 SI 2j+1 < n-1 ET T[2j+2] > T[k] ALORS k := 2j+2 echanger T[j] et T[k]JUSQU'A j = k

PROCEDURE modifier_tas(T[0..n-1], i, v)(* on veut changer la valeur v du noeud i en préservant la propriété du tas *)

Données : tableau T, noeud i, valeur vRésultat : T est de nouveau un tasx := T[i]T[i] := vSI v < x ALORS tamiser(T, i)SINON percoler(T, i)

Cette propriété du tas en fait une structure de données idéale pour trouver le maximum, éliminer la racine, ajouter un nœud et modifier un nœud. Ce sont précisément les opérations voulues pour l'implémentation efficace d'une liste de priorité dynamique : la valeur d'un nœud indique la priorité de l'événement correspondant. L'événement le plus prioritaire se trouve toujours à la racine et il est toujours possible de modifier dynamiquement la priorité d'un événement.

PROCEDURE eliminer_racine(T[0..n-1])Données : tableau TRésultat : T[0..n-2] est de nouveau un tasT[0] := T[n-1]tamiser(T,0)supprimer(T[n-1])



PROCEDURE ajouter_noeud(T[0..n-1], v)Données : tableau T, valeur vRésultat : T[0..n] est de nouveau un tasT[n] := vpercoler(T,n)

Exercice 6.7Exercice 6.7Écrivez un programme Python qui gère un tas : représentez le tas par un tableau. puis

programmez les procédures ou fonctions suivantes : percoler, tamiser, modifier_tas, maximum, eliminer_racine, ajouter_noeud.

Écrivez enfin une procédure qui crée un tas de n valeurs tirées aléatoirement.

6.9. Table de hachageUne table de hachage (hash table en anglais) est une structure de donnée permettant d'associer

une valeur à une clé. Il s'agit d'un tableau ne comportant pas d'ordre (un tableau est indexé par des entiers). L'accès à un élément se fait en transformant la clé en une valeur de hachage (ou simplement hachage) par l'intermédiaire d'une fonction de hachage. Le hachage est un nombre qui permet la localisation des éléments dans le tableau, typiquement le hachage est l'indice de l'élément dans le tableau. Une case dans le tableau est appelée alvéole.

Une table de hachage implémentant un annuaire téléphonique

Différentes opérations peuvent être effectuées sur une table de hachage :• création d'une table de hachage • insertion d'un nouveau couple (clé, valeur)• suppression d'un élément • recherche de la valeur associée à une clé (dans l'exemple de l'annuaire, retrouver le numéro

de téléphone d'une personne) • destruction d'une table de hachage (pour libérer la mémoire occupée)

Tout comme les tableaux, les tables de hachage permettent un accès en O(1) en moyenne, quel que soit le nombre d'éléments dans la table. Toutefois, le temps d'accès dans le pire des cas peut être de O(n). Comparées aux autres tableaux associatifs, les tables de hachage sont surtout utiles lorsque le nombre d'entrées est très important.

La position des éléments dans une table de hachage est aléatoire. Cette structure n'est donc pas adaptée pour accéder à des données triées.



6.9.1. Choix d'une bonne fonction de hachageLe fait de créer un hachage à partir d'une clé peut engendrer un problème de collision, c'est-à-dire

qu'à partir de deux clés différentes, la fonction de hachage pourrait renvoyer la même valeur de hachage, et donc par conséquent donner accès à la même position dans le tableau. Pour minimiser les risques de collisions, il faut donc choisir soigneusement sa fonction de hachage.

Les collisions étant en général résolues par des méthodes de recherche linéaire, une mauvaise fonction de hachage, i.e. produisant beaucoup de collisions, va fortement dégrader la rapidité de la recherche.

Le calcul du hachage se fait parfois en 2 temps :1. une fonction de hachage particulière à l'application est utilisée pour produire un nombre

entier à partir de la donnée d'origine 2. ce nombre entier est converti en une position possible de la table, en général en calculant le

reste modulo la taille de la table. Les tailles des tables de hachage sont souvent des nombres premiers, afin d'éviter les problèmes

de diviseurs communs, qui créeraient un nombre important de collisions. Une alternative est d'utiliser une puissance de deux, ce qui permet de réaliser l'opération modulo par de simples décalages, et donc de gagner en rapidité.

Un problème fréquent et surprenant est le phénomène de « clustering » qui désigne le fait que des valeurs de hachage se retrouvent côte à côte dans la table, formant des « clusters » (« grappes » en français). Ceci est très pénalisant pour les techniques de résolution des collisions par adressage ouvert (voir ci-après). Les fonctions de hachage réalisant une distribution uniforme des hachages sont donc les meilleures, mais sont en pratique difficile à trouver.

La fonction de hash primaire (la flèche en haut) calcule une adresse et génère une collision.La première case libre en ordre croissant, ici en bleu, est trouvée et utilisée, consolidant ainsi deux clusters, provoquant une congestion supplémentaire.

Exercice 6.8Exercice 6.8Programmez en Python la fonction hashCode(s) de la chaîne s de longueur n, qui renvoie le

hachage ord(s[0])*32^(n−1) + ord(s[1])*32^(n−2) + ... + ord(s[n−1]) mod N, où ord est la fonction qui renvoie le code ASCII d'un caractère et N la taille de la table de hachage.

Testez cette fonction avec les noms « Chico », « Groucho », « Gummo », « Harpo », « Zeppo » et N=5, puis N=11, puis N=12.

6.9.2. Résolution des collisionsLorsque deux clés ont la même valeur de hachage, ces clés ne peuvent être stockées à la même

position, on doit alors employer une stratégie de résolution des collisions.Pour donner une idée de l'importance d'une bonne méthode de résolution des collisions,

considérons ce résultat issu du paradoxe des anniversaires3. Même si nous sommes dans le cas le plus favorable où la fonction de hachage a une distribution uniforme, il y a 95% de chances d'avoir une collision dans une table de taille 1 million avant qu'elle ne contienne 2500 éléments.

De nombreuses stratégies de résolution des collisions existent mais les plus connues et utilisées sont le chaînage et l'adressage ouvert.

3 Le paradoxe des anniversaires est à l'origine une estimation probabiliste du nombre de personnes que l'on doit réunir pour avoir une chance sur deux que deux personnes de ce groupe aient leur anniversaire le même jour de l'année. Il se trouve que ce nombre est 23, ce qui choque l'intuition. À partir d'un groupe de 57 personnes, la probabilité est supérieure à 99 %.



ChaînageCette méthode est la plus simple. Chaque case de la table est en fait une liste chaînée des clés qui

ont le même hachage. Une fois la case trouvée, la recherche est alors linéaire en la taille de la liste chaînée. Dans le pire des cas où la fonction de hachage renvoie toujours la même valeur de hachage quelle que soit la clé, la table de hachage devient alors une liste chaînée, et le temps de recherche est en O(n). L'avantage du chaînage est que la suppression d'une clé est facile ainsi que la recherche.

Résolution des collisions par chaînage

D'autres structures de données que les listes chaînées peuvent être utilisées. En utilisant un arbre équilibré, le coût théorique de recherche dans le pire des cas est en O(log n). Cependant, la liste étant supposée être courte, cette approche est en général peu efficace à moins d'utiliser la table à sa pleine capacité, ou d'avoir un fort taux de collisions.

Adressage ouvertL'adressage ouvert consiste, dans le cas d'une collision, à stocker les valeurs de hachage dans

d'autres alvéoles vides. On appelle ce procédé une méthode de sondage : on essaie les alvéoles h(k,0), h(k,1), ..., jusqu'à ce qu'on trouve une alvéole vide. Il y a trois méthodes de sondage :

Sondage linéaireSoit H : U → {0, ... N−1} une fonction de hachage auxiliaire.La fonction de sondage linéaire sera : h(k,i) = (H(k) + i) mod N, avec i = 0, 1, ..., N−1

Résolution des collisions par adressage ouvert et sondage linéaire



Cette manière de faire s'appelle en anglais « lazy deletion », suppression paresseuse.

Sondage quadratiqueSoit H : U → {0, ... N−1} une fonction de hachage auxiliaire.La fonction de sondage quadratique sera : h(k,i) = (H(k) + c1·i + c2·i2) mod N, avec i = 0, 1, ..., N−1, c1 et c2 ≠ 0

Double hachageSoient H1 et H2 : U → {0, ... N−1} deux fonctions de hachage auxiliaires.La fonction de sondage par double hachage sera : h(k,i) = (H1(k) + i·H2(k)) mod N, avec i = 0, 1, ..., N−1, c1 et c2 ≠ 0

RechercheLors d'une recherche, si l'alvéole obtenue par hachage direct ne permet pas d'obtenir la bonne clé,

une recherche sur les cases obtenues par une méthode de sondage est effectuée jusqu'à trouver la clé, ou tomber sur une alvéole vide, ce qui indique qu'aucune clé de ce type n'appartient à la table.

SuppressionDans un adressage ouvert, la suppression d'un élément de la table de hachage est délicate. Dans le

schéma ci-après, si l'on supprime « John Smith » sans précaution, on ne retrouvera plus « Sandra Dee ». La manière la plus simple de s'en sortir est de ne pas vider la alvéole où se trouvait « John Smith », mais d'y placer le mot « Supprimé ». On distinguera ainsi les alvéoles vides des alvéoles où un nom a été effacé : une alvéole contenant « Supprimé » sera considérée comme occupée lors d'une suppression, mais vide lors d'une insertion.

Facteur de chargeUne indication critique des performances d'une table de hachage est le facteur de charge qui est la

proportion de cases utilisées dans la table. Plus le facteur de charge est proche de 100%, plus le nombre de sondages à effectuer devient important. Lorsque la table est presque pleine, les algorithmes de sondage peuvent même échouer : ils peuvent ne plus trouver d'alvéole vide, alors qu'il y en a encore.

Le facteur de charge est en général limité à 80%, même en disposant d'une bonne fonction de hachage. Des facteurs de charge faibles ne sont pas pour autant significatifs de bonne performance, en particulier si la fonction de hachage est mauvaise et génère du clustering.

Exercice 6.9Exercice 6.9On souhaite stocker des nombres entiers positifs en utilisant une table de hachage. La table

possédant N emplacements (de 0 à N−1), on utilise la clef suivante: h(x)=x modulo N.1. Calculez la valeur de la clé pour chacun des éléments de la liste suivante (N=12) : 15, 24,

125, 4, 26, 6, 78, 55, 89, 16, 124 2. En supposant que les éléments soient inclus dans la table de hachage dans l'ordre de la liste

et que la résolution des collisions soit faite par chaînage, dessinez la table obtenue. 3. En supposant que les éléments soient inclus dans la table de hachage dans l'ordre de la liste

et que la résolution des collisions soit faite par un sondage linéaire, dessinez la table obtenue.

Exercice 6.10Exercice 6.10Utilisez la fonction de hachage programmée dans l'exercice 6.8 dans une table de taille N=12. Implémentez une classe « table_de_hachage ».Écrivez une méthode « inserer », qui insère un nouvel abonné (nom et numéro de téléphone) dans

l'annuaire.Écrivez une méthode « rechercher », qui affiche le numéro de téléphone d'un abonné. Si plusieurs

abonnés portent le même nom, la méthode affichera les différents numéros.Écrivez une méthode « supprimer », qui retire un abonné de l'annuaire.Testez ensuite votre programme avec les données suivantes :

Chico 0324661193Groucho 0324667543



Gummo 0324664578Harpo 0324668501Zeppo 0324660031Zeppo 0324660032

Faites cet exercice deux fois : une fois en résolvant les collisions par chaînage et l'autre fois en les résolvant par adressage ouvert (avec un sondage linéaire).

Sources[1] Wikipédia, « Structures de données »,

<http://fr.wikipedia.org/wiki/Catégorie:Structure_de_données>

[2] Wikipédia, « Arbre (Structures de données) », <http://fr.wikipedia.org/wiki/Catégorie:Arbre_(structure_de_données)>

[3] Wikipédia, « Arbre binaire », <http://fr.wikipedia.org/wiki/Arbre_binaire>

[4] Wikipédia, « Arbre binaire de recherche », <http://fr.wikipedia.org/wiki/Arbre_binaire_de_recherche>

[5] Wikipédia, « Arbre AVL », <http://fr.wikipedia.org/wiki/Arbre_AVL>

[6] Wikipédia, « Table de hachage », <http://fr.wikipedia.org/wiki/Table_de_hachage>

[7] Wikipédia, « Fonction de hachage », <http://fr.wikipedia.org/wiki/Fonction_de_hachage>

[8] Nicod Jean-Marc, « Les tables de hachage », <http://ifc.univ-fcomte.fr/~nicod/slidesHashTableL3.pdf>


http://fr.wikipedia.org/wiki/Cat%C3%A9gorie:Structure_de_donn%C3%A9es

http://ifc.univ-fcomte.fr/~nicod/slidesHashTableL3.pdf

http://fr.wikipedia.org/wiki/Fonction_de_hachage

http://fr.wikipedia.org/wiki/Table_de_hachage

http://fr.wikipedia.org/wiki/Arbre_AVL

http://fr.wikipedia.org/wiki/Arbre_binaire_de_recherche

http://fr.wikipedia.org/wiki/Arbre_binaire

http://fr.wikipedia.org/wiki/Arbre_binaire

http://fr.wikipedia.org/wiki/Cat%C3%A9gorie:Arbre_(structure_de_donn%C3%A9es


http://ow.ly/36Jth

Chapitre 7Algorithmique

On désigne par algorithmique l'ensemble des activités logiques qui relèvent des algorithmes ; en particulier, en informatique, cette discipline désigne l'ensemble des règles et des techniques qui sont impliquées dans la définition et la conception des algorithmes.

7.1. Quelques définitionsLe mot « algorithme » vient du nom du mathématicien Al Khwarizmi, qui, au 9ème siècle écrivit

le premier ouvrage systématique sur la solution des équations linéaires et quadratiques. La notion d'algorithme est donc historiquement liée aux manipulations numériques, mais elle s'est progressivement développée pour porter sur des objets de plus en plus complexes : des textes, des images, des formules logiques, des objets physiques, etc.

Un algorithme est un énoncé d'une suite d'opérations permettant de donner la réponse à un problème.

• Si les opérations s'exécutent sur plusieurs processeurs en parallèle, on parle d'algorithme parallèle.

• Si les tâches s'exécutent sur un réseau de processeurs on parle d'algorithme distribué. • Un algorithme qui contient un appel à lui-même est dit récursif. • Un algorithme glouton est un algorithme qui suit le principe de faire, étape par étape, un

choix optimum local, dans l'espoir d'obtenir un résultat optimum global. Dans les cas où l'algorithme ne fournit pas systématiquement la solution optimale, il est appelé une heuristique gloutonne.

• En optimisation combinatoire, théorie des graphes et théorie de la complexité, une heuristique est un algorithme qui fournit rapidement (en temps polynomial) une solution réalisable, mais pas nécessairement optimale, pour un problème d'optimisation difficile. Une heuristique, ou méthode approximative, est donc le contraire d'un algorithme exact qui trouve une solution optimale pour un problème donné. L'usage d'une heuristique est pertinente pour calculer une solution approchée d'un problème et ainsi accélérer le processus de résolution exacte.

• Les métaheuristiques forment une famille d'algorithmes d'optimisation visant à résoudre des problèmes d'optimisation difficile (souvent issus des domaines de la recherche opérationnelle, de l'ingénierie ou de l'intelligence artificielle) pour lesquels on ne connaît pas de méthode classique plus efficace. Ces méthodes utilisent cependant un haut niveau d'abstraction, leur permettant d'être adaptées à une large gamme de problèmes différents. Les métaheuristiques les plus connues sont la recherche avec tabous, le recuit simulé, les algorithmes génétiques et les colonies de fourmis.

Exemple 1 : Algorithme d'EuclideDonné ci-après sous forme d'organigramme, l'algorithme d'Euclide permet de trouver le plus

grand diviseur commun de deux nombres (A > B).

Didier Müller 7-1 Janvier 2012

Algorithmique

Euclide (Athènes, -325 -

Alexandrie, -265)

http://ow.ly/4tqcY

Exercice 7.1Exercice 7.1Programmez l'algorithme d'Euclide en Python.

Exemple 2 : Multiplication à la russeIl existe une méthode pour multiplier deux nombres où il ne faut que

savoir multiplier ou diviser par deux, et additionner. On appelle cette méthode "multiplication à la russe".

1. Dans la colonne de gauche, on divise par deux en prenant la partie entière et on s'arrête à 1.

2. Dans la colonne de droite, on double successivement chaque nombre.

3. On raye à droite tous les chiffres en face d'un nombre pair. 4. On fait la somme des nombres de droite restants.

JustificationRemplacer dans la colonne de gauche chaque nombre impair par 1 et chaque nombre pair par 0

revient à exprimer le nombre de gauche en base 2, si on lit de haut en bas. Les opérations effectuées sur la colonne de droite correspondent alors à une multiplication dans la base 2.

Exercice 7.2Exercice 7.2Programmez cet algorithme en Python et estimez le nombre d'opérations moyen pour aboutir au

résultat de la multiplication.

7.2. Les tours de HanoiLe casse-tête des tours de Hanoï est un jeu de réflexion

consistant à déplacer des disques de diamètres différents d'une tour de « départ » à une tour d' « arrivée » en passant par une tour « intermédiaire » et ceci en un minimum de coups, tout en respectant les règles suivantes :

• on ne peut pas déplacer plus d'un disque à la fois, • on ne peut placer un disque que sur un autre disque plus grand que lui ou sur un

emplacement vide. On suppose que cette dernière règle est également respectée dans la configuration de départ.


http://ow.ly/4tqcY


Le problème mathématique des tours de Hanoï a été inventé par Édouard Lucas (1842-1891). Il est publié dans le tome 3 de ses Récréations mathématiques, parues à titre posthume en 1892. Il annonce que ce problème est dû à un de ses amis, N. Claus de Siam, prétendument professeur au collège de Li-Sou-Stian (une double anagramme de Lucas d'Amiens, sa ville de naissance, et Saint Louis, le lycée où Lucas enseignait).Sous le titre « Les brahmes tombent », Lucas relate que « N. Claus de Siam a vu, dans ses voyages pour la publication des écrits de l'illustre Fer-Fer-Tam-Tam, dans le grand temple de Bénarès, au-dessous du dôme qui marque le centre du monde, trois aiguilles de diamant, plantées dans une dalle d'airain, hautes d'une coudée et grosses comme le corps d'une abeille. Sur une de ces aiguilles, Dieu enfila au commencement des siècles, 64 disques d'or pur, le plus large reposant sur l'airain, et les autres, de plus en plus étroits, superposés jusqu'au sommet. C'est la tour sacrée du Brahmâ. Nuit et jour, les prêtres se succèdent sur les marches de l'autel, occupés à transporter la tour de la première aiguille sur la troisième, sans s'écarter des règles fixes que nous venons d'indiquer, et qui ont été imposées par Brahma. Quand tout sera fini, la tour et les brahmes tomberont, et ce sera la fin des mondes !».

Un jeu à 64 disques requiert un minimum de 264−1 déplacements. En admettant qu'il faille 1 seconde pour déplacer un disque, ce qui fait 86'400 déplacements par jour, la fin du jeu aurait lieu au bout d'environ 213'000 milliards de jours, ce qui équivaut à peu près à 584,5 milliards d'années, soit 43 fois l'âge estimé de l'univers (13,7 milliards d'années selon certaines sources).

7.2.1. Résolution récursivePour résoudre le problème des tours de Hanoï, il faut raisonner récursivement. Nous allons partir

de l'exemple trivial pour aller vers des problèmes de plus en plus complexes : • S'il n'y a qu'un disque, il suffit de le déplacer de A vers C. • S'il y a deux disques, il faut déplacer le petit disque de A vers B, déplacer le plus grand de A

vers C, puis le petit de B vers C. • Avec trois disques, il faudra d'abord déplacer les deux disques du dessus de A vers B,

déplacer le plus grand de A vers C, puis replacer les deux disques sur le grand.

En résumé, déplacer n disques de A vers C en passant par B consiste à :• déplacer (n−1) disques de A vers B (en passant par C); • déplacer le plus grand disque de A vers C ; • déplacer (n−1) disques de B vers C (en passant par A).


Algorithmique

Ce qui donne en Python :

def hanoi(n,de,a,par): if n>0: hanoi(n-1, de, par, a) print(de,"-->",a) hanoi(n-1, par, a, de)

print("""Tours de HanoiIl faut deplacer les disques de la tour A vers la tour C""")n = int(input("Nombre de disques : "))hanoi(n,"A","C","B")

7.2.2. Résolution itérativeIl existe également une procédure itérative pour résoudre le problème des tours de Hanoï. Elle

consiste à effectuer successivement les deux déplacements suivants : • déplacer le plus petit disque d'un emplacement à l'emplacement suivant (de A vers B, de B

vers C, de C vers A, par exemple) • déplacer un autre disque

et à poursuivre itérativement ces deux déplacements jusqu'à ce que la tour complète soit déplacée, le dernier déplacement se limitant alors à celui du plus petit disque sur le sommet de la tour. L'action de déplacer un autre disque est non ambiguë puisque, en dehors du plus petit disque, un seul mouvement d'un autre disque est possible.

Contrairement à la procédure récursive, la procédure itérative n'utilise aucune mémorisation de l'arbre des déplacements à effectuer et nécessite seulement de se souvenir si on doit déplacer le plus petit disque ou non, et dans quel sens sont effectués les déplacements du petit disque. Il permet également, à tout moment, de revenir à la situation de départ : il suffit pour cela d'inverser le sens dans lequel se déplace le plus petit disque.

Exercice 7.3Exercice 7.3Écrivez un programme en Python résolvant les tours de Hanoi sans utiliser la récursivité.

Réutilisez la classe Pile que vous avez implémentée à l'exercice 6.1.

7.3. Le problème des huit damesLe but du problème des huit dames, est de placer huit dames

d'un jeu d'échecs sur un échiquier de 8×8 cases sans que les dames ne puissent se menacer mutuellement, conformément aux règles du jeu d'échecs. Par conséquent, deux dames ne devraient jamais partager la même rangée, colonne, ou diagonale (voir dessin ci-contre).

Durant des années, beaucoup de mathématiciens, y compris Gauss ont travaillé sur ce problème, qui est un cas particulier du problème généralisé des n-dames, posé en 1850 par Franz Nauck, et qui est de placer n dames « libres » sur un échiquier de n×n cases. En 1874, S. Gunther proposa une méthode pour trouver des solutions en employant des déterminants, et J. W. L. Glaisher affina cette approche.

Le problème des huit dames a 92 solutions distinctes, ou seulement 12 solutions si l'on tient compte de transformations telles que des rotations ou des réflexions (voir dessin ci-après).

Le problème des huit dames est un bon exemple de problème simple mais non évident. Pour cette raison, il est souvent employé comme support de mise en œuvre de différentes techniques de programmation, y compris d'approches non traditionnelles de la programmation telles que la programmation par contraintes, la programmation logique ou les algorithmes génétiques.



7.3.1. Algorithme naïfL'algorithme naïf de recherche exhaustive teste toutes les manières possibles de placer une dame

par colonne, pour retirer toutes celles pour lesquelles des dames se menacent mutuellement.Il y a 88 = 16'777'216 placements à explorer.

Exercice 7.4Exercice 7.4 Programmez l'algorithme naïf pour trouver les 92 solutions au problème des huit dames.

Vous représenterez la position par une liste de nombres de 0 à 7. Ces nombres indiquent la ligne sur laquelle la dame se trouve pour la colonne correspondante. Par exemple, la 12ème solution du graphique ci-dessus sera représentée par la liste : [2,4,1,7,0,6,3,5].

7.3.2. Recherche en profondeurLa recherche en profondeur consiste à trouver les solutions en plaçant les dames de gauche à

droite. Prenons pour simplifier un exemple sur un damier 4x4. Imaginons que toutes les solutions avec la première dame sur la première ligne ont été trouvées (voir dessin ci-dessous).


Algorithmique

On veut maintenant placer la première dame sur la 2ème ligne. Plaçons la deuxième dame sur la ligne 1. Il y a conflit : STOP. On ne cherche pas plus loin. Idem

pour les lignes 2 et 3. La seule solution possible est la 4ème ligne. Plaçons maintenant la troisième dame. On peut la mettre sur la première ligne sans conflit.Plaçons alors la 4ème et dernière dame. La seule ligne possible est la 3ème. On a une solution :

[1,3,0,2].On remonte alors dans l'arbre : la troisième dame ne peut se placer sur aucune autre ligne.Remontons encore d'un cran.On a déjà essayé toutes les lignes pour la deuxième dame.Remontons encore d'un cran : plaçons la première dame sur la 3ème ligne et recommençons une

recherche en profondeur...

Exercice 7.5Exercice 7.5Programmez la recherche en profondeur expliquée ci-dessus. Comptez le nombre de situations

(intermédiaires et finales) analysées.

7.3.3 Méthode heuristiqueUn algorithme de « réparation itérative » commence typiquement à partir d'un placement de

toutes les dames sur l'échiquier, par exemple avec une seule dame par ligne et par colonne. Il essaie ensuite toutes les permutations des colonnes (il n'y a que des conflits diagonaux à tester) pour ne garder que les configurations sans conflits.

Il y a 8! = 40'320 placements à explorer.

Exercice 7.6Exercice 7.6Placez initialement les 8 dames sur la diagonale de l'échiquier, puis échangez deux colonnes

choisies au hasard. Répétez l'opération jusqu'à ce qu'une solution soit trouvée.

Exercice 7.7Exercice 7.7Modifiez le programme de l'exercice 7.6 pour trouver les 92 solutions. Le programme ci-dessous

pourra vous aider. N'essayez pas de le comprendre, il fait appel à des notions avancées de Python que l'on n'a pas vues (Iterators et generators). Contentez-vous de l'intégrer à votre programme.

def all_perms(str): if len(str)<=1: yield str else: for perm in all_perms(str[1:]): for i in range(len(perm)+1): yield perm[:i] + str[0:1] + perm[i:]

for p in all_perms([0,1,2]): print(p)

Le résultat sera :[0, 1, 2][1, 0, 2][1, 2, 0][0, 2, 1][2, 0, 1][2, 1, 0]

7.4. Algorithmes gloutonsUn algorithme glouton (en anglais : greedy) est un algorithme qui suit le principe de faire, étape

par étape, un choix optimum local, dans l'espoir d'obtenir un résultat optimum global. Il n'y a pas de retour en arrière : à chaque étape de décision dans l'algorithme, le choix qui semble le meilleur à ce moment est effectué et est définitif. Les algorithmes gloutons servent surtout à résoudre des problèmes d'optimisation.



Exemple : rendu de monnaieDans le problème du rendu de monnaie (donner une somme avec le moins possible de pièces),

l'algorithme consistant à répéter le choix de la pièce de plus grande valeur qui ne dépasse pas la somme restante est un algorithme glouton.

Suivant le système de pièces, l'algorithme glouton est optimal ou pas. Dans le système de pièces européen (en centimes : 1, 2, 5, 10, 20, 50, 100, 200), où l'algorithme glouton donne la somme suivante pour 37 : 20+10+5+2, on peut montrer que l'algorithme glouton donne toujours une solution optimale.

Dans le système de pièces (1, 3, 4), l'algorithme glouton n'est pas optimal. En effet, il donne pour 6 : 4+1+1, alors que 3+3 est optimal.

Exercice 7.8Exercice 7.8Une route comporte n stations-service, numérotées dans l'ordre du parcours, de 0 à n−1. La

première est à une distance d[0] du départ, la deuxième est à une distance d[1] de la première, la troisième à une distance d[2] de la deuxième, etc. La fin de la route est à une distance d[n] de la n-ième et dernière station-service.

Un automobiliste prend le départ de la route avec une voiture dont le réservoir d'essence est plein. Sa voiture est capable de parcourir une distance r avec un plein.

Question 7.8.1

Donnez une condition nécessaire et suffisante pour que l'automobiliste puisse effectuer le parcours. On la supposera réalisée par la suite.

Question 7.8.2

Prenez 17 stations-service avec les distances d = [23, 40, 12, 44, 21, 9, 67, 32, 51, 30, 11, 55, 24, 64, 32, 57, 12, 80] et r = 100.

L'automobiliste désire faire le plein le moins souvent possible. Écrivez une fonction Python rapide qui détermine à quelles stations-service il doit s'arrêter.

Exercice 7.9Exercice 7.9Un cambrioleur entre par effraction dans une maison. Il n'est capable de porter que K kilos : il lui

faudra donc choisir entre les différents objets de valeur, afin d'amasser le plus gros magot possible.On supposera dans un premier temps que les objets sont fractionnables (on peut en prendre

n'importe quelle quantité, c'est le cas d'un liquide ou d'une poudre). Il y a n matières différentes, numérotées de 0 à n−1, la i-ème ayant un prix p[i] par kilo. La quantité disponible de cette matière est q[i]. On suppose que tous les prix sont différents deux à deux.

Question 7.9.1

Proposez un algorithme qui donne un choix optimal pour le voleur. Ce choix est-il unique ?Programmez une fonction voleur en Python qui reprenne cet algorithme (vous pourrez supposer

que le tableau p est trié).

Prenez par exemple : p = [43, 40, 37, 33, 28, 25, 20, 17, 14, 13], q = [7, 6, 12, 11, 2, 23, 1, 4, 24, 43], K = 55.

Question 7.9.2

On suppose maintenant que les objets sont non fractionnables (c'est le cas d'un vase ou d'un téléviseur). Le i-ème objet vaut un prix p[i] et pèse un poids q[i].

Proposez une méthode dérivée de la question 1 (sans la programmer). Donne-t-elle un choix optimal ?


Algorithmique

http://ow.ly/4tpWm

7.5. Algorithmes de triUne des opérations les plus courantes en programmation est

le tri d'objets. Les ordres les plus utilisés sont l'ordre numérique et l'ordre lexicographique.

Les principales caractéristiques qui permettent de différencier les algorithmes de tri sont la complexité algorithmique (voir annexe) et les ressources nécessaires (notamment en terme d'espace mémoire utilisé) .

On peut montrer que la complexité temporelle en moyenne et dans le pire des cas d'un algorithme basé sur une fonction de comparaison ne peut pas être meilleure que O(n·log(n)). Les tris qui ne demandent que O(n·log(n)) comparaisons en moyenne sont alors dits optimaux.

Dans les algorithmes ci-dessous, on effectuera des tris par ordre croissant.

7.5.1. Tri par sélectionLe tri par sélection est un des algorithmes de tri les plus triviaux. On recherche le plus grand élément que l'on va replacer à sa position finale, c'est-à-dire en

dernière position. Puis on recherche le second plus grand élément que l'on va placer en avant-dernière position, etc.,

jusqu'à ce que le tableau soit entièrement trié.

def swap(l,i,j): # echange 2 valeurs d'une liste l[i],l[i] = l[j], l[i]

def tri_selection(l): for i in range(len(l)-1): mini=i for j in range(i+1,len(l)): if l[j]<l[mini]: mini=j swap(l,i,mini)

Complexité• Meilleur des cas : O(n2) quand le tableau est déjà trié.• Pire cas : O(n2) quand le tableau est trié en ordre inverse.• En moyenne : O(n2).

7.5.2. Tri à bulles (Bubble sort)Le tri à bulles est un algorithme de tri qui consiste à faire remonter progressivement les plus

petits éléments d'une liste, comme les bulles d'air remontent à la surface d'un liquide. L'algorithme parcourt la liste, et compare les couples d'éléments successifs. Lorsque deux

éléments successifs ne sont pas dans l'ordre croissant, ils sont échangés. Après chaque parcours complet de la liste, l'algorithme recommence l'opération. Lorsqu'aucun échange n'a lieu pendant un parcours, cela signifie que la liste est triée : l'algorithme peut s'arrêter.

Cet algorithme est souvent enseigné en tant qu'exemple algorithmique. Cependant, il présente une complexité en O(n2) dans le pire des cas (où n est la longueur de la liste), ce qui le classe parmi les mauvais algorithmes de tri. Il n'est donc quasiment pas utilisé en pratique.

def swap(l,i,j): # echange 2 valeurs d'une liste l[i],l[j] = l[j],l[i]

def tri_a_bulles(l): for i in range(len(l)): for j in reversed(range(i,len(l))): if l[j]<l[j-1]: swap(l,j-1,j)


http://ow.ly/4tpWm


Complexité• Meilleur cas : O(n) quand le tableau est trié.• Pire des cas : O(n2) quand le tableau est trié en ordre inverse (n−1)·(n−1) = O(n²)

7.5.3. Tri par insertionLe tri par insertion est le tri le plus efficace sur des listes de petite taille. C'est pourquoi il est

utilisé par d'autres méthodes comme le Quicksort (voir § 7.5.4). Il est d'autant plus rapide que les données sont déjà triées en partie dans le bon ordre.

Le principe de ce tri est très simple : c'est le tri que toute personne utilise naturellement quand elle a des dossiers (ou n'importe quoi d'autre) à classer. On prend un dossier et on le met à sa place parmi les dossiers déjà triés. Puis on recommence avec le dossier suivant.

Pour procéder à un tri par insertion, il suffit de parcourir une liste : on prend les éléments dans l'ordre. Ensuite, on les compare avec les éléments précédents jusqu'à trouver la place de l'élément qu'on considère. Il ne reste plus qu'à décaler les éléments du tableau pour insérer l'élément considéré à sa place dans la partie déjà triée.

def tri_insertion(liste): j = 1 n = len(liste) while j != n: i = j - 1 temp = liste[j] while i > -1 and liste[i] > temp: liste[i+1] = liste[i] i = i - 1 liste[i+1] = temp j = j + 1

Complexité• Pire cas : O(n2) quand le tableau est trié en ordre inverse • Moyenne : O(n2)

7.5.4. QuicksortLe Quicksort est une méthode de tri inventée par Sir Charles Antony Richard Hoare en 1961 et

fondée sur la méthode de conception « diviser pour régner ». Il peut être implémenté sur un tableau ou sur des listes ; son utilisation la plus répandue concerne tout de même les tableaux.

Le Quicksort est un tri dont la complexité moyenne est en O(n·log(n)), mais dont la complexité dans le pire des cas est un comportement quadratique en O(n2). Malgré ce désavantage théorique, c'est en pratique un des tris les plus rapide pour des données réparties aléatoirement. Les entrées donnant lieu au comportement quadratique dépendent de l'implémentation de l'algorithme, mais sont souvent (si l'implémentation est maladroite) les entrées déjà presque triées. Il sera plus avantageux alors d'utiliser le tri par insertion.

La méthode consiste à placer un élément du tableau (appelé pivot) à sa place définitive, en permutant tous les éléments de telle sorte que tous ceux qui lui sont inférieurs soient à sa gauche et que tous ceux qui lui sont supérieurs soient à sa droite. Cette opération s'appelle le partitionnement.

Pour chacun des sous-tableaux, on définit un nouveau pivot et on répète l'opération de partitionnement. Ce processus est répété récursivement, jusqu'à ce que l'ensemble des éléments soit trié.

Dans la pratique, pour les partitions avec un faible nombre d'éléments (jusqu'à environ 15 éléments), on a souvent recours à un tri par insertion qui se révèle plus efficace que le Quicksort.

Le problème le plus important est le choix du pivot. Une implémentation du Quicksort qui ne choisit pas adéquatement le pivot sera très inefficace pour certaines entrées. Par exemple, si le pivot est toujours le plus petit élément de la liste, Quicksort sera aussi inefficace qu'un tri par sélection, c'est-à-dire de performance O(n2).


Algorithmique

def partition(tab, debut, fin): while debut < fin: while debut < fin: if tab[debut] > tab[fin]: tab[debut], tab[fin] = tab[fin], tab[debut] break fin = fin - 1 while debut < fin: if tab[debut] > tab[fin]: tab[debut], tab[fin] = tab[fin], tab[debut] break debut = debut + 1 return debut def quicksort(tab, debut=None, fin=None): if debut is None: debut = 0 if fin is None: fin = len(tab) if debut < fin: i = partition(tab, debut, fin-1) quicksort(tab, debut, i) quicksort(tab, i+1, fin)

Complexité• Pire des cas : O(n2) quand le tableau est trié en ordre inverse • En moyenne et dans le meilleur des cas : O(n·log(n))



7.5.5. Tri par fusion (Mergesort)Le tri par fusion repose sur le fait que, pour fusionner deux listes/tableaux trié(e)s dont la somme

des longueurs est n, n−1 comparaisons au maximum sont nécessaires. Pour aller aussi vite que le Quicksort, il a donc besoin d'utiliser O(n) mémoire supplémentaire, mais il a l'avantage d'être stable c'est-à-dire de ne pas mélanger ce qui est déjà trié.

L'algorithme peut être décrit récursivement :

1. On découpe en deux parties à peu près égales les données à trier.

2. On trie les données de chaque partie.3. On fusionne les deux parties.

La récursivité s'arrête car on finit par arriver à des listes composées d'un seul élément et le tri est alors trivial.

On peut aussi utiliser un algorithme itératif :

1. On trie les éléments deux à deux.2. On fusionne les listes obtenues.3. On recommence l'opération précédente

jusqu'à ce qu'on ait une seule liste triée.

Complexité• Moyenne et pire des cas : O(n log(n))

def merge(l1, l2): liste = [] i = j =0 n1=len(l1) n2=len(l2) while True: if i<n1 and j<n2: if l1[i]<l2[j]: liste.append(l1[i]) i+=1 else: liste.append(l2[j]) j+=1 elif i>=n1: liste.extend(l2[j:]) break else: liste.extend(l1[i:]) break return liste

def tri_fusion(liste): def tri_fusion_interne(liste): if len(liste)<2 : return liste return merge(tri_fusion_interne(liste[:len(liste)//2]),

tri_fusion_interne(liste[len(liste)//2:])) liste[:] = tri_fusion_interne(liste)


Algorithmique

7.5.6. Tri par tas (Heapsort)Cet algorithme permet de trier les éléments d'un tableau en O(n log (n)) dans le pire des cas, où n

est le nombre d'éléments à trier. Les principaux atouts de cette méthode sont la faible consommation mémoire et l'efficacité optimale.

PrincipeL'idée qui sous-tend cet algorithme consiste à voir le tableau comme un arbre binaire. Le premier

élément est la racine, le deuxième et le troisième sont les deux descendants du premier élément, etc. Ainsi le n-ième élément a pour fils les éléments 2n+1 et 2n+2. Si le tableau n'est pas de taille 2n, les branches ne se finissent pas tout à fait à la même profondeur.

Dans l'algorithme, on cherche à obtenir un tas, c'est-à-dire un arbre binaire vérifiant les propriétés suivantes (les deux premières propriétés découlent de la manière dont on considère les éléments du tableau) :

• la différence maximale de profondeur entre deux feuilles est de 1 (i.e. toutes les feuilles se trouvent sur la dernière ou sur l'avant-dernière ligne) ;

• les feuilles de profondeur maximale sont « tassées » sur la gauche. • chaque nœud est de valeur supérieure à celles de ses deux fils, pour un tri ascendant.

Comme expliqué au paragraphe 6.4.2, un tas ou un arbre binaire presque complet peut être stocké dans un tableau, en posant que les deux descendants de l'élément d'indice n sont les éléments d'indices 2n+1 et 2n+2 (pour un tableau indicé à partir de 0). En d'autres termes, les nœuds de l'arbre sont placés dans le tableau ligne par ligne, chaque ligne étant décrite de gauche à droite.

Une fois le tas de départ obtenu, l'opération de base de ce tri est le tamisage d'un élément, supposé le seul « mal placé » dans un arbre qui est presque un tas. Plus précisément, considérons un arbre T = T[0] dont les deux sous-arbres (T[1] et T[2]) sont des tas, tandis que la racine est éventuellement plus petite que ses fils. L'opération de tamisage consiste à échanger la racine avec le plus grand de ses fils, et ainsi de suite récursivement jusqu'à ce qu'elle soit à sa place.

Pour construire un tas à partir d'un arbre quelconque, on tamise les racines de chaque sous-tas, de bas en haut (par taille croissante) et de droite à gauche.

Pour trier un tableau à partir de ces opérations, on commence par le transformer en tas. On échange la racine avec le dernier élément du tableau, et on restreint le tas en ne touchant plus au dernier élément, c'est-à-dire à l'ancienne racine. On tamise la racine dans le nouveau tas, et on répète l'opération sur le tas restreint jusqu'à l'avoir vidé et remplacé par un tableau trié.

def faire_tas(tab, debut, n): # transforme le tableau "tab" en un tas racine = debut while racine*2 + 1 < n: fils = racine*2 + 1 if fils < n-1 and tab[fils] < tab[fils+1]: fils += 1 if tab[racine] < tab[fils]: tab[racine], tab[fils] = tab[fils], tab[racine] racine = fils else: return

def heapsort(tab): n = len(tab) debut = n//2 - 1 fin = n - 1 while debut >= 0: faire_tas(tab, debut, n) debut -= 1 while fin > 0: tab[fin], tab[0] = tab[0], tab[fin] faire_tas(tab, 0, fin) fin -= 1



7.6. Tester si un point est dans un polygone Dans le plan, étant donné un polygone simple (dont les arêtes ne se coupent pas), comment

déterminer si un point se trouve à l'intérieur ou à l'extérieur de ce polygone ?

MéthodeLa méthode la plus utilisée est de tracer une demi-droite de ce point vers l'infini et de compter les

intersections entre cette droite et les segments du polygone.• Tracer une demi-droite à partir du point vers l'infini. • Calculer le nombre L d'intersections entre cette demi-droite et les côtés du polygone. • Un nombre L impair indique que le point est à l'intérieur. • Il faut bien sûr faire attention aux coins qui tombent juste sur la demi-droite.

Nombre pair d'intersection : Nombre impair d'intersections :point à l'extérieur point à l'intérieur

7.6.1. Pour savoir si deux segments se coupentLa première chose à faire est de trouver une méthode pour localiser un point P par rapport à une

ligne passant par les points P0 et P1. Le dessin ci-dessous illustre les trois possibilités.Pour différencier ces trois cas, on peut utiliser les déterminants. En effet, rappelons-nous qu'un

déterminant peut être interprété comme une aire signée.

Ainsi, sur le dessin ci-contre :

dét(P0P1, P0P2) > 0dét(P0P1, P0P3) < 0dét(P0P1, P0P4) = 0

où les PiPj désignent des vecteurs-colonnes et dét un déterminant 2x2.

On dira que :

orientation(P0, P1, P2) = 1orientation(P0, P1, P3)= −1orientation(P0, P1, P4)= 0

D'où la condition ci-dessous :


Algorithmique

SI orientation(Q0,Q1,P0) ≠ orientation(Q0,Q1,P1) ET orientation(P0,P1,Q0) ≠ orientation(P0,P1,Q1) ALORS RETOURNER « les deux segments se coupent »

Exercice 7.10Exercice 7.10Écrivez un programme Python qui implémente la méthode vue ci-dessus. Le polygone sera donné

par la liste de ses sommets. Vous trouverez sur le site compagnon une ébauche à compléter.

7.7. Enveloppe convexeImaginons une planche avec des clous qui dépassent. Englobons ces points avec un élastique que

l'on relâche. Le polygone obtenu (en bleu ci-dessous) est l'enveloppe convexe (convex hull).

En trois dimensions, l'idée serait la même avec un ballon qui se dégonflerait jusqu'à être en contact avec tous les points qui sont à la surface de l'enveloppe convexe.

Plusieurs algorithmes ont été inventés pour calculer l'enveloppe convexe d'un semis de points. Leur complexité varie. Nous allons ici en étudier deux parmi les plus connus : la marche de Jarvis et le parcours de Graham.

7.7.1. Marche de Jarvis (Gift wrapping algorithm)La marche de Jarvis est un algorithme qui « enveloppe » un

ensemble de points dans un « papier cadeau » : on accroche ce papier à un point initial p1, puis on le tend, et on tourne autour du nuage de points Le premier point rencontré par le papier sera p1, puis p2, ... jusqu'à retrouver p0.

On construit donc l'enveloppe convexe segment par segment, en partant du point p0. Il ne doit y avoir aucun point à gauche du prochain segment pi pi+1. Il n'y a qu'un point pi+1 qui satisfait cette condition ; il faut le chercher parmi les points qui ne sont pas encore sur l'enveloppe convexe. On s'arrête lorsque pi+1 = p0.

Remarquons que les points ne sont pas triés, alors que ce sera le cas pour le parcours de Graham.

Cet algorithme doit son nom à R. A. Jarvis, qui publia cet algorithme en 1973.



ComplexitéLa complexité est en O(nh), où n est le nombre total de sommets et où h représente le nombre de

sommets de l'enveloppe convexe. On qualifie ce genre d'algorithme de « sensible à la sortie ».

Exercice 7.11Exercice 7.11Écrivez un programme Python qui implémente la marche de Jarvis. Vous trouverez sur le site

compagnon une ébauche à compléter.

7.7.2. Parcours de Graham (Graham's scan)Cet algorithme doit son nom à Ronald Graham, qui a publié l'algorithme original en 1972.La première étape de cet algorithme consiste à rechercher le point le plus à gauche. S'il y a égalité

entre plusieurs points, l'algorithme choisit parmi eux le point de plus petite ordonnée. Nommons P0

ce point. La complexité en temps de cette étape est en O(n), n étant le nombre de points de l'ensemble.

Les autres points Pi sont ensuite triés en fonction de la pente du segment P0Pi, de la plus grande pente à la plus petite. N'importe quel algorithme efficace de tri convient pour cela. À l'issue de cette étape, on dispose d'un tableau T contenant les points ainsi triés. P0 sera le premier élément de ce tableau.

L'algorithme considère ensuite successivement les séquences de trois points contigus dans le tableau T, vus comme deux segments successifs. On regarde ensuite si ces deux segments mis about à bout constitue un « tournant à gauche » ou un « tournant à droite ».

• Si l'on rencontre un « tournant à droite », l'algorithme passe au point suivant de T. • Si c'est un « tournant à gauche », cela signifie que l'avant-dernier point considéré (le

deuxième des trois) ne fait pas partie de l'enveloppe convexe, et qu'il doit être enlevé de T. Cette analyse se répète ensuite, tant que l'ensemble des trois derniers points est un « tournant à gauche » .

Le processus se terminera quand on retombera sur le point P0. T contiendra alors les points formant l'enveloppe convexe.

ComplexitéLe tri des points peut se faire avec une complexité en temps en O(nlog(n)). La complexité de la

boucle principale peut sembler être en O(n2), parce que l'algorithme revient en arrière à chaque point pour évaluer si l'un des points précédents est un « tournant à droite ». Mais elle est en fait en O(n),


Algorithmique

parce que chaque point n'est considéré qu'une seule fois. Ainsi, chaque point analysé soit termine la sous-boucle, soit est retiré de T et n'est donc plus jamais considéré. La complexité globale de l'algorithme est donc en O(nlog(n)), puisque la complexité du tri domine la complexité du calcul effectif de l'enveloppe convexe.

Exercice 7.12Exercice 7.12Écrivez un programme Python qui implémente le parcours de Graham. Vous trouverez sur le site

compagnon une ébauche à compléter.

7.8. Recherche de nombres premiersExercice 7.13Exercice 7.13

Implémentez un algorithme simple permettant de savoir si un nombre est premier ou non. Complétez ensuite ce programme pour écrire tous les nombres premiers entre 2 et N.

Le Crible d'EratosthèneL'algorithme procède par élimination : il s'agit de supprimer d'une table tous les multiples des

entiers de 2 à N. À la fin du processus, tous les entiers qui n'ont pas été biffés sont les nombres premiers inférieurs à N.

Voici, étape par étape, le détail de la mise en œuvre de l'algorithme pour N=20.

Étape 1. Écrivons la liste des nombres naturels compris entre 2 et 20 :

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Étape 2. On souligne le premier nombre de la liste non biffé et non souligné :

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Étape 3. On biffe dans la liste tous les multiples du nombre que l'on vient de souligner :

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Étape 4. Si le carré du premier nombre de la liste non biffé et non souligné est inférieur à N, alors on recommence à l'étape 2. Sinon on déclare tous les entiers restants non biffés premiers.

Puisque 3 élevé au carré est inférieur à 20, on retourne à l'étape 2, puis on applique l'étape 3, à savoir biffer tous les multiples de 3 :

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

À l'étape 4, le nombre suivant non biffé (5) a un carré strictement supérieur à 20. L'algorithme s'arrête. Tous les nombres non biffés sont premiers, à savoir : 2, 3, 5, 7, 11, 13, 17, 19.

Exercice 7.14Exercice 7.14Implémentez le crible d'Eratosthène pour écrire tous les nombres premiers inférieurs à N. Pour

cela, adaptez le programme suivant :

N = 21liste = list(range(N)) # liste des entiers de 0 à 20print(liste)print(liste[5::5]) # écrit les multiples de 5liste[10::5] = [0]*((N//5)-1) # remplace les multiples de 5 par 0print(liste)



7.9. Algorithmes probabilistesUn algorithme probabiliste est un algorithme dont le déroulement fait appel à des données tirées

au hasard. Dans leur ouvrage Algorithmique, conception et analyse, G. Brassard et P. Bratley classent les algorithmes probabilistes en quatre catégories :

Algorithmes numériques• Utilisés pour approcher la solution à des problèmes numériques (ex. calcul de pi, intégration

numérique, etc.). • La précision augmente avec le temps disponible. • Certains auteurs classent ces algorithmes dans la catégorie Monte Carlo

Algorithmes de Sherwood• Utilisés lorsqu'un algorithme déterministe fonctionne plus rapidement en moyenne qu'en

pire cas. • Ces algorithmes peuvent éliminer la différence entre bonnes et mauvaises entrées. • Exemple : Quicksort

Algorithmes de Las Vegas• Ces algorithmes peuvent parfois retourner un message disant qu'ils n'ont pas pu trouver la

réponse. • La probabilité d'un échec peut être rendu arbitrairement petite en répétant l'algorithme

suffisamment souvent.

Algorithmes de Monte Carlo• Ces algorithmes retournent toujours une réponse mais celle-ci n'est pas toujours juste. • La probabilité d'obtenir une réponse correcte augmente avec le temps disponible.

Exercice 7.15Exercice 7.15Modifiez le programme de l'exercice 7.10 qui teste si un point est à l'intérieur d'un polygone, afin

d'estimer l'aire de ce polygone. Pour ce faire, vous générerez 100'000 points au hasard et calculerez le pourcentage de points « tombés » à l'intérieur du polygone.

Exercice 7.16Exercice 7.16Développez et programmez une méthode basée sur l'estimation de l'aire d'un quart de cercle pour

approcher la valeur de π.

7.9.1. Test de primalité de Miller-RabinLe test de Miller-Rabin est un algorithme de Monte Carlo qui peut décider avec un taux d'erreur

très faible si un nombre est premier ou composé. Ce test est en fait un test de non-primalité, c'est-à-dire que s'il répond qu'un nombre n'est pas premier, alors il est sûr que ce nombre ne l'est pas. Il peut aussi répondre qu'un nombre est probablement premier. Dans ce cas, si ce nombre n'est pas premier, la probabilité de ne pas avoir été détecté non premier est infime : on peut imposer par exemple que cette probabilité soit inférieure à 2-100.

L'algorithme peut être écrit de la façon suivante :

Données : n : une valeur impaire à tester pour sa primalité ; k : un paramètre qui détermine le nombre de fois qu'il faut tester la primalité. Résultat : "composé" si on trouve pour n au moins un Témoin de Miller a, autrement il est "très probablement premier"


Algorithmique

FONCTION miller_rabin(n,k) écrire n comme 2^r × s + 1 REPETER k fois : prendre a aléatoirement dans l'intervalle [1, n-1] SI a^s mod n≠1 et a^(s·2^j) mod n≠-1 pour tout j dans [0, r-1] ALORS RETOURNER "composé" RETOURNER "probablement premier"

Plus on teste de valeurs de a (donc plus k est grand), meilleure est la précision du test. Monier (1980) et Rabin (1980) ont montré qu'un nombre composé passe le test pour au plus 1/4 des valeurs a. Si l'on fait k fois le test, alors on se trompera environ 1 fois sur 4k.

# Miller-Rabin# teste si un nombre est premier

import random

def en_binaire(n): r = [] while n>0: r.append(n%2) n = n//2 return r

def test(a, n): # vrai : n est composé # faux : n est PROBABLEMENT premier b = en_binaire(n-1) d = 1 for i in range(len(b)-1, -1, -1): x = d d = (d*d) % n if d==1 and x!=1 and x!=n-1: return True # composé if b[i]==1: d=(d*a)%n if d!=1: return True # composé return False # premier

def MillerRabin(n, k = 50): for j in range(1, k+1): a = random.randint(1, n-1) if (test(a, n)): return False # composé return True # premier

print("Nombres probablement premiers : ")for n in range(1000000001,1000000999,2): if MillerRabin(n): print(n)

7.9.2. Le compte est bonD'après le jeu « Des chiffres et des lettres » d'Armand Jammot (France 2).

Le principe du jeu En choisissant 6 nombres (on peut choisir plusieurs fois le même) dans l'ensemble {1, 2, 3, 4, 5,

6, 7, 8, 9, 10, 25, 50, 75, 100} et en leur appliquant les quatre opérations élémentaires (addition, soustraction, multiplication et division), il s'agit d'atteindre le résultat demandé (ceci est possible dans 94% des cas). Tous les résultats des calculs intermédiaires doivent être des nombres entiers positifs. Chacun des nombres (parmi ceux de départ et ceux obtenus par un calcul intermédiaire) ne peut être utilisé qu'une fois au plus. Si le résultat demandé ne peut pas être atteint, il faut l'approcher au plus près.



http://ow.ly/4tqwT

Exemple : atteindre 952 avec les nombres 25, 50, 75, 100, 3, 6. 100 + 3 = 103103 x 6 = 618618 x 75 = 4635046350 / 50 = 927927 +25 = 952

Il existe des programmes sophistiqués trouvant en quelques dixièmes de secondes toutes les solutions. Nous allons ici nous contenter d'une méthode naïve et peu efficace, mais facile à programmer : il s'agira de rechercher aléatoirement des solutions et de ne garder que celle qui se rapproche le plus du résultat demandé.

Données : six nombres dans une liste L et le résultat r à approcher.

1. Choisir deux nombres a et b au hasard dans la liste L. 2. Choisir une opération arithmétique (+, -, *, /) au hasard. L'opération doit

être possible (par exemple, on ne peut pas diviser 5 par 9) et utile (il est inutile par exemple de multiplier un nombre par 1).

3. Poser c := opération(a, b). Mémoriser ce calcul intermédiaire dans une chaîne de caractères (une string).

4. Éliminer a et b de la liste L. 5. Ajouter c à la liste L. 6. SI c = r ALORS

afficher tous les calculs intermédiaires. STOP

7. SI il y a plus d'un nombre dans la liste ALORS aller à 1 SINON afficher la liste des calculs intermédiaires et le résultat obtenu

On répétera cet algorithme des milliers de fois et on n'affichera que la meilleure solution trouvée.

Exercice 7.17Exercice 7.17Programmez cet algorithme en Python.

7.10. Le problème des n dames pour illustrer lesmétaheuristiques

Le problème des n dames est une généralisation de du problème des 8 dames, vu au paragraphe 7.3 : on considère un échiquier nxn au lieu d'un échiquier 8x8. Bien que ce ne soit pas à proprement parlé un problème d'optimisation, il présente de nombreux avantages :

• il est visuel et facile à comprendre ; • on peut coder la position des dames très simplement :

pour chaque colonne, on note sur quelle ligne se trouve la dame. La position ci-contre sera : [2, 4, 6, 8, 3, 1, 7, 5]

• on passe très facilement d'une configuration à une configuration voisine (qui ne satisfait pas forcément les contraintes du problème) : il suffit d'échanger deux colonnes. Une position voisine de celle ci-contre pourrait être [2, 1, 6, 8, 3, 4, 7, 5].

On peut le traiter comme un problème d'optimisation si l'on considère qu'il faut minimiser le nombre de conflits (on parlera de conflit quand deux dames se menacent mutuellement). Il s'agira ici de placer n dames sur l'échiquier nxn, sans aucun conflit, en partant d'une solution avec une seule dame par ligne et par colonne (par exemple toutes les dames sur la diagonale) et en échangeant deux colonnes. On ne cherchera pas toutes les solutions possibles : une seule nous suffira. Notons que dans un problème d'optimisation classique, il n'y a en général qu'une seule meilleure solution. Ici il y en a plusieurs.


http://ow.ly/4tqwT

http://ow.ly/4tqwT

Algorithmique

Il est à noter qu'il existe un algorithme permettant de trouver une solution quel que soit n supérieur à 3 (voir exercice 7.18). L'intérêt de l'exercice n'est donc pas de trouver une solution, mais d'illustrer sur ce problème classique comment se comportent trois des métaheuristiques les plus connues : la recherche avec tabous, le recuit simulé et un algorithme génétique.

Exercice 7.18Exercice 7.181. soit r = n mod 122. écrire les nombres pairs de 2 à n3. si r = 3 ou r = 9 mettre le 2 à la fin de la liste4. écrire ensuite les nombres impairs de 1 à n, mais si r=8 permuter les nombres

impairs 2 par 2 (i.e. 3, 1, 7, 5, 11, 9, ...)5. si r = 2, permuter les places de 1 et 3, puis mettre 5 à la fin de la liste6. si r = 3 ou r = 9, mettre 1 puis 3 en fin de liste

Programmez cet algorithme en Python. Il donnera une solution au problème des n dames. Ainsi, pour n=8 on obtient la position [2, 4, 6, 8, 3, 1, 7, 5]. Pour n=15, on aura la solution [4, 6, 8, 10, 12, 14, 2, 5, 7, 9, 11, 13, 15, 1, 3].

Vérifiez la validité de cet algorithme pour n = 4 ... 1000.

7.10.1. Première approche : descente de plus grande penteÀ partir d'une position donnée, essayer toutes les permutations de deux colonnes et échanger les

deux colonnes qui permettent de diminuer le plus le nombre de conflits.Répéter le processus jusqu'à avoir 0 conflit (dans l'idéal) ou un blocage.

Résultats avec la descente de plus grande penteNombre de dames (n) 20 40 60 80 100Temps ou nombre de conflits restants 2 conflits 13 sec. 1 conflit 418 sec. 1308 sec.

Commentaires• Selon la position initiale et le nombre de dames, il arrive que l'algorithme se bloque dans un

minimum local. C'est arrivé ici avec 20 et 60 dames placées au départ sur la diagonale.• Avec 100 dames, on passe d'une situation avec 4950 conflits à une configuration sans

conflit en 82 échanges de colonnes.• Les temps sont seulement indicatifs et dépendent évidemment de l'ordinateur utilisé. Toutes

les expériences ont été faites sur le même ordinateur et dans les mêmes conditions.

7.10.2. Deuxième approche : recherche avec tabousLa méthode taboue est une métaheuristique d'optimisation présentée par Fred Glover en 1986.

On trouve souvent l'appellation « recherche avec tabous » en français.La méthode taboue consiste, à partir d'une position donnée, à explorer le voisinage et à choisir la

position dans ce voisinage qui minimise la fonction objectif (comme dans la descente de plus grande pente). Il est essentiel de noter que cette opération peut conduire à dégrader la valeur de la fonction : c'est le cas lorsque tous les points du voisinage ont une valeur plus élevée. Le risque est qu'à l'étape suivante, on retombe dans le minimum local auquel on vient d'échapper. C'est pourquoi il faut que l'heuristique ait de la mémoire : le mécanisme consiste à interdire (d'où le nom de « tabou ») de revenir sur les dernières positions explorées.

Les positions déjà explorées sont conservées dans une file (voir § 6.2), souvent appelée liste des tabous, d'une taille donnée. Cette file doit conserver des positions complètes, mais cela ne pose pas de problèmes avec les n dames. Pour nos expériences, nous avons utilisé une liste de 10 mouvements tabous.



Résultats avec la méthode taboue

Nombre de dames (n) 20 40 60 80 100

Temps ou nombre de conflits restants 1 sec. 15 sec. 114 sec. 422 sec. 1756 sec.

Commentaires• Le programme ne se bloque plus dans un minimum local.• La solution finale est toujours la même et dépend de la position initiale.• Avec 100 dames, on passe d'une situation avec 4950 conflits à une configuration sans

conflit en 95 échanges de deux colonnes.

7.10.3. Troisième approche : recuit simuléLe recuit simulé (Simulated Annealing en anglais) est une métaheuristique inspirée d'un

processus utilisé en métallurgie. Ce processus alterne des cycles de refroidissement lent et de réchauffage (recuit) qui tendent à minimiser l'énergie du matériau. Elle est aujourd'hui utilisée en optimisation pour trouver les extrema d'une fonction.

Elle a été mise au point par trois chercheurs de la société IBM, S. Kirkpatrick, C.D. Gelatt et M.P. Vecchi en 1983, et indépendamment par V. Cerny en 1985.


Algorithmique

Ce qu'on appelle « modification élémentaire » dans ce schéma consistera simplement à échanger deux colonnes choisies aléatoirement.

L'énergie sera dans notre problème le nombre de conflits.Le réglage des paramètres est ici plus délicat. En particulier, comment faut-il faire baisser la

température ? Trop vite, on risque de se bloquer dans un minimum local. Trop lentement, le temps de calcul augmentera, sans garantie de trouver une solution.

La solution retenue a été de faire baisser la température par palier de longueur 10, avec une température initiale T=100, avec Tk+1=0.6·Tk, k représentant un numéro de palier. C'est très inhabituel, car on prend généralement un coefficient proche de 1.

Résultats avec le recuit simuléNombre de dames (n) 20 40 60 80 100Temps moyen en cas de succès* 0.3 sec. 1.5 sec 4 sec. 9 sec. 23 sec.Nombre de succès sur 10 essais 7 10 10 10 10

*Il s'agit d'une moyenne sur 10 essais, puisque le hasard joue ici un rôle important. Les temps des essais où l'on n'a pas trouvé de solution n'ont pas été pris en compte.

Commentaires• Étant donné l'usage du hasard, on ne sait pas quelle solution finale sera trouvée. Ce ne sera

pas toujours la même, contrairement à la recherche avec tabous.• Curieusement, le recuit simulé marche le moins bien quand il y a peu de dames (7 succès

seulement avec 20 dames).• Il est par contre redoutable en temps de calcul, puisqu'il ne lui faut que 23 secondes pour

trouver une solution avec 100 dames, alors que la méthode taboue en mettait 1756.

7.10.4. Quatrième approche : algorithme génétiqueLes algorithmes génétiques appartiennent à la famille des algorithmes évolutionnistes (un sous-

ensemble des métaheuristiques). Leur but est d'obtenir une solution approchée, en un temps correct, à un problème d'optimisation, lorsqu'il n'existe pas ou qu'on ne connaît pas de méthode exacte pour le résoudre en un temps raisonnable. Les algorithmes génétiques utilisent la notion de sélection naturelle développée au XIXe siècle par le scientifique Darwin et l'appliquent à une population de solutions potentielles au problème donné. On se rapproche par bonds successifs d'une solution, comme dans une procédure de séparation et évaluation, à ceci près que ce sont des formules qui sont recherchées et non plus directement des valeurs.

L'utilisation d'algorithmes génétiques, dans la résolution de problèmes, est à l'origine le fruit des recherches de John Holland et de ses collègues et élèves de l'Université du Michigan qui ont, dès 1960, travaillé sur ce sujet. La nouveauté introduite par ce groupe de chercheurs a été la prise en compte de l'opérateur d'enjambement en complément des mutations. Et c'est cet opérateur qui permet le plus souvent de se rapprocher de l'optimum d'une fonction en combinant les gènes contenus dans les différents individus de la population. Le premier aboutissement de ces recherches a été la publication en 1975 de Adaptation in Natural and Artificial System.



• Les positions « enfants » sont générées en combinant deux positions « parents ». • L'algorithme commence avec un ensemble de k configurations générées aléatoirement

appelé population. (a) • Chaque position est représentée pas une liste de n nombres indiquant la ligne occupée pour

la colonne correspondante. Avec 8 dames, la configuration ci-dessous est représentée par la liste [0, 5, 1, 4, 6, 3, 7, 2].

• Chaque configuration est évaluée grâce à la fonction de performance. (b) • Une phase de reproduction détermine quelles positions seront sélectionnées pour la

reproduction. Certaines positions peuvent être reproduites plusieurs fois, d'autres jamais. (c) • Pour chaque paire se combinant, on détermine aléatoirement le point de croisement. (c) • Les enfants sont créés en permutant les points de croisement dans chaque paire. (d) • Finalement, chaque configuration subit une mutation aléatoire. (e)

Croisement de positions[2, 1, 6, 4, 1, 3, 0, 0] + [1, 3, 6, 3, 7, 4, 4, 1] = [2, 1, 6, 3, 7, 4, 4, 1]

Commentaire• Cette approche n'a pour l'instant pas donné de résultats intéressants. Elle ne fonctionne

qu'avec de petits damiers. Il semble difficile de choisir les différents paramètres.

Sources[1] Wikipédia, « Algorithmique », <http://fr.wikipedia.org/wiki/Algorithmique>

[2] Wikipédia, « Algorithmes de tri », <http://fr.wikipedia.org/wiki/Catégorie:Algorithme_de_tri>

[3] Wikipédia, « Marche de Jarvis », <http://fr.wikipedia.org/wiki/Marche_de_Jarvis>

[4] Wikipédia, « Parcours de Graham », <http://fr.wikipedia.org/wiki/Parcours_de_Graham>

[5] Wikipédia, « Test de primalité de Miller-Rabin », <http://fr.wikipedia.org/wiki/Test_de_primalité_de_Miller-Rabin>

[6] Wikipédia, « Méta-heuristique », <http://fr.wikipedia.org/wiki/Métaheuristique>

[7] Wikipédia, « Recuit simulé », <http://fr.wikipedia.org/wiki/Recuit_simulé>

[8] Wikipédia, « Algorithme génétique », <http://fr.wikipedia.org/wiki/Algorithme_génétique>


http://fr.wikipedia.org/wiki/Algorithmique

http://fr.wikipedia.org/wiki/Recuit_simul%C3%A9

http://fr.wikipedia.org/wiki/M%C3%A9taheuristique


http://fr.wikipedia.org/wiki/Parcours_de_Graham


http://fr.wikipedia.org/wiki/Cat%C3%A9gorie:Algorithme_de_tri



http://ow.ly/5iIy8

Chapitre 8Intelligence artificielle et jeux

Intelligence artificielle : Partie de l'informatique qui a pour but la simulation de facultés cognitives afin de suppléer l'être humain pour assurer des fonctions dont on convient, dans un contexte donné, qu'elles requièrent de l'intelligence. Langages : Lisp, Prolog. => Reconnaissance de formes et de la parole, simulation, jeu, conduite de robots, apprentissage.

L'intelligence artificielle (IA) comprend plusieurs domaines :• le dialogue automatique : se faire comprendre d'un ordinateur en lui parlant ;• la traduction automatique, si possible en temps réel ou très légèrement différé ;• le traitement automatique des langues ;• le raisonnement automatique (systèmes experts) ;• l'apprentissage automatique ;• la reconnaissance de formes, des visages et la vision en général ; • l'intégration automatique d'informations provenant de sources hétérogènes ;• l'aide aux diagnostics ;• l'aide à la décision ;• la résolution de problèmes complexes, tels que les problèmes d'allocation de ressources. • l'assistance par des machines dans les tâches dangereuses, ou demandant une grande

précision.

L'intelligence artificielle est utilisée (ou intervient) dans une variété de domaines tels que :• la banque, avec des systèmes experts d'évaluation de risque lié à l'octroi d'un crédit ;• le militaire, avec les systèmes autonomes tels que les drones ;• les jeux, domaine qui va plus particulièrement nous intéresser ici ; • la médecine, avec les systèmes experts d'aide au diagnostic ;

Didier Müller 8-1 octobre 2011

http://ow.ly/5iIy8

Intelligence artificielle et jeux

• la logistique, au travers d'approches heuristiques de type résolution de problème de satisfaction de contraintes ;

• l'éducation.

MMOG : massively multiplayer online game

8.1. Différents types de jeuxUn jeu est un terrain d'expérimentation idéal pour l'intelligence artificielle (IA). Les règles

simples et peu nombreuses, les situations bien définies modélisent un mode simplifié mais quand même intéressant. Les jeu bien connu « Les Sim's » en est un bon exemple. Pour l'ordinateur, les choix sont réduits, les configurations faciles à analyser, les conséquences des choix sont calculables. Pensons à des jeux comme les échecs, les dames, mais aussi des jeux où le hasard intervient comme le backgammon, le poker, où l'ordinateur aura à calculer des probabilités.

Le terme d' « intelligence artificielle » est très pompeux. Certains parlent en ce domaine de force brute et non pas d'intelligence artificielle. On verra en effet qu'il s'agira uniquement de calculs et d'exploration d'arbre de jeu. Il est vrai que l'ordinateur donne l'impression d'une certaine intelligence1 quand il joue contre un humain. L'auteur se souvient encore du choc qu'il a ressenti quand, dans les années 80, il a joué (et perdu) pour la première fois aux échecs contre une machine. Comment cet objet sans vie faisait-il ? C'est ce que nous allons étudier dans ce chapitre.

8.1.1. Jeux vidéoC'est dans les jeux vidéo que l'intelligence artificielle s'est le plus popularisée, et c'est aussi un

des domaines où elle se développe rapidement. Celle-ci bénéficie en effet des progrès de l'informatique, avec par exemple les cartes graphiques dédiées qui déchargent le processeur principal des tâches graphiques. Le processeur principal peut désormais être utilisé pour développer des systèmes d'IA plus perfectionnés.

Par exemple, l'intelligence artificielle peut être utilisée pour piloter des bots (c'est-à-dire les personnages artificiels) évoluant dans les MMOGs ou les mondes virtuels, mais on peut aussi citer son utilisation dans des jeux de simulation, ou pour animer des personnages artificiels.

Dans le domaine du jeu vidéo, l'IA caractérise toute prise de décision d'un personnage (ou d'un groupe) géré par le jeu, et contraint par l'intérêt ludique. Jusqu'à la fin des années 1990, l'IA dans les jeux vidéo (plus particulièrement dans les jeux en temps réel) a été délaissée par rapport au rendu visuel et sonore. L'évolution vers des univers toujours plus réalistes, leur peuplement par des personnages aux comportements crédibles devient une problématique importante.

Avec les jeux en réseau, le besoin d'IA a tout d'abord été négligé, mais, particulièrement avec l'apparition des jeux massivement multijoueur, et la présence d'un nombre très important de joueurs humains se confrontant à des personnages non joueur (PNJ), ces derniers doivent s'adapter à des situations qui ne peuvent être prévues. Actuellement ces types de jeux intéressent particulièrement des chercheurs en IA.

8.1.2. Jeux de réflexionUn ordinateur peut simuler la prudence, la malice, voire l'intelligence. Tel est le cas lorsqu'un

programme permet à un ordinateur de rivaliser avec un être humain dans un jeu de stratégie qui, à l'évidence, mobilisera la réflexion de ce dernier.

1979 : Le champion du monde battu au BackgammonLe premier logiciel de valeur, BKG 9.8, a été conçu par Hans Berliner dans les années 1970 sur

un DEC PDP-10 pour expérimenter l'évaluation des positions des jeux de tablier. Les versions précédentes de BKG n'étaient pas en mesure de battre de manière répétitive des joueurs débutants, mais Berliner remarqua que ses erreurs critiques se situaient toujours dans des phases de transition de la partie. Il appliqua les principes de la logique floue pour améliorer son jeu au cours de ces phases, et en juillet 1979, BKG 9.8 devint suffisamment fort pour jouer contre le champion mondial Luigi Villa. Il gagna la rencontre 7-1, devenant le premier logiciel à battre un champion du monde dans un jeu de tablier. Berliner constata cependant que la victoire était due en grande partie à la

1 Encore faudrait-il définir ce qu'est l'intelligence. Donnez votre définition et discutez-en en groupe.



Voir [2] pour un historique plus complet.

chance du fait d'un plus grand nombre de résultats favorables obtenus par le logiciel.Dans les années 1980, les informaticiens obtinrent plus de succès avec une approche basée sur

l'utilisation de réseaux de neurones artificiels. TD-Gammon, développé par Gerald Tesauro chez IBM, fut le premier de ces logiciels à atteindre un niveau proche de celui d'un joueur expérimenté. Son réseau de neurones était entraîné par auto-apprentissage. Selon Bill Robertie et Kit Woolsey, deux grands joueurs de backgammon, le jeu de TD-Gammon était alors à la hauteur, et même au-dessus, de celui des meilleurs joueurs du monde. Woolsey déclara ainsi « Il n'y a aucun doute dans mon esprit que son analyse des positions est de beaucoup supérieure à la mienne. »

Les recherches basées sur les réseaux artificiels de neurones ont abouti à la génération de trois logiciels commerciaux modernes, Jellyfish, Snowie et eXtreme Gammon, ainsi qu'au partagiciel BGBlitz et au logiciel libre GNU Backgammon. La force de ces logiciels repose sur des mois d'entraînement de leurs réseaux de neurones sans lesquels ils ne pourraient pas dépasser le niveau d'un joueur novice. La phase de sortie des dames est généralement traitée par les logiciels à partir d'une base de données – obtenue par ordinateur – contenant toutes les positions possibles des dames au moment de la sortie.

1997 : Deep Blue bat Garry Kasparov aux ÉchecsDepuis les années 1990, les ordinateurs sont capables de battre le champion de monde d'échecs.

Mais l'histoire des programmes d'échecs est longue. Il aura fallu un demi-siècle pour passer d'un programme connaissant les règles du jeu à un ordinateur capable de battre le champion du monde.

• 1948, le livre Cybernétique de Norbert Wiener décrit comment un programme d'échecs peut être développé en utilisant une profondeur minimale de recherche avec une fonction d'évaluation.

• 1951, Alan Turing développe sur le papier le premier programme capable de jouer une partie d'échecs complète.

• 1958, les premiers programmes qui sont capables de jouer une partie complète sont créés, le premier par Alex Bernstein et l'autre par des programmeurs russes sur mainframe BESM.

• 1966-1967, le premier match entre programmes d'échecs voit le jour. Le programme Kaissa de l'Institut de physique théorique et expérimentale de Moscou triomphe de Kotok-McCarthy de l'université Stanford. Les coups étaient échangés par télégraphe et le match a duré 9 mois.

• 1967, Max Hack 6 de Richard Greenblatt devient le premier programme à gagner contre une personne en tournoi.

• 1974, Kaissa devient le premier champion du monde des ordinateurs. • 1977, le premier jeu d'échecs électronique, Chess Challenger, est commercialisé. Et devient

la même année le premier ordinateur à remporter un tournoi d'échecs majeur. • 1985, HiTech réalise une performance Elo de 2530, c'est le premier programme à atteindre

le classement de 2400 (niveau d'un maître international).• 1994, Fritz 3 gagne une partie de blitz contre le champion du monde de l'époque, Garry

Kasparov et ils terminent ex æquo. Kasparov prend sa revanche dans le départage : 4-1. Cette même année à Londres, Chess Genius bat Garry Kasparov en partie semi-rapide (1.5-0.5) avec un Pentium 100 MHz.

• 1997, Deep Blue bat Garry Kasparov. (2 victoires, 3 nulles et 1 défaite).

• 2005, Hydra gagne face à Michael Adams par 5 victoires et une nulle contre 0 victoire. • 2006, Deep Fritz gagne face à Vladimir Kramnik par 2 victoires et 4 nulles contre 0

victoire.



2008 : Chinook imbattable aux DamesDes scientifiques canadiens ont mis au point un programme d'ordinateur impossible à battre au

jeu de dames. Une formidable avancée dans le domaine de l'intelligence artificielle. Jonathan Schaeffer, détenteur de la chaire de sciences informatiques à l'université d'Alberta (Canada), aidé par d'autres informaticiens de cet établissement, se sont acharnés durant 18 ans à programmer les quelque 500 milliards de milliards de combinaisons possibles au jeu de dames, un grand classique du genre répandu dans le monde entier.

Et le résultat est là : Chinook, puisque c'est le nom du logiciel, s'avère impossible à battre. Au pire, il conduira une partie jusqu'à une impasse débouchant sur la nullité, et confronté à un autre ordinateur utilisant le même programme, ne produira que des parties nulles.

Pour mettre au point son programme, Schaeffer a mobilisé environ 50 ordinateurs quotidiennement depuis 1989, parfois jusqu'à 200 dans les moments critiques, et a fait appel à plusieurs joueurs professionnels.

À l'origine, Chinook avait été élaboré pour participer au Championnat du Monde de Dames. Perdant en finale en 1992, il l'a remporté deux ans plus tard en devenant ainsi le premier logiciel à obtenir un titre mondial dans un jeu de compétition. Mais estimant alors que les ordinateurs de nouvelle génération devraient permettre de créer un programme infaillible, Schaeffer se remettait au travail en 2001 pour arriver au résultat actuel.

Il est possible de... perdre contre Chinook sur le site http://webdocs.cs.ualberta.ca/~chinook

Go : le graalSon apparente simplicité semble faire du go un candidat idéal à l'exploration informatique. Mais

des difficultés considérables ne tardent pas à surgir. La taille du goban détermine une combinatoire qui dépasse de très loin les possibilités de calcul des ordinateurs (la taille très approximative de l'arbre des possibilités du jeu de go est environ de 10600, le nombre 361!/100! des différentes parties de plus de 260 coups). Cette difficulté est amplifiée par d'autres caractéristiques du jeu : la nature de la condition de victoire, le placement virtuellement illimité de chaque pierre, la nature non locale de la règle du ko, le haut niveau de reconnaissance de formes exigé. Pour ces raisons, certains chercheurs en intelligence artificielle considèrent le go comme un meilleur test que les échecs.

À partir de 2006, la programmation du jeu de go a fait des progrès importants notamment grâce à la méthode de Monte-Carlo. Les programmes parviennent désormais à égaler des joueurs de haut niveau sur un goban de taille 9x9 ou à des handicaps de 6 à 9 pierres sur un goban de taille 19x19. En 2009, les meilleurs programmes sont parvenus (en parties rapides) à obtenir un niveau de 1er dan amateur sur le serveur KGS.

8.1.3. Jeux de connaissance

2011 : un ordinateur bat deux champions au JeopardyEn remportant deux manches sur trois, Watson a gagné 1 million de dollars au jeu Jeopardy (un

jeu où on donne la réponse et où il faut deviner la question).L'écran était installé entre les deux joueurs humains et l'ordinateur, commandé par un opérateur,

devait répondre aux questions de culture générale posées par l'animateur. Watson (du nom du fondateur d'IBM, Thomas Watson) étant sourd et muet, l'opérateur tapait les questions sur le clavier et annonçait ses réponses. Ses adversaires humains n'étaient pas les premiers venus : la machine a combattu en effet les deux plus brillants compétiteurs de l'histoire de ce jeu, revenus sur le plateau pour ce match du siècle.

Avec ses 15 To (téraoctets) de mémoire vive, ses 2.880 processeurs Power 7, Watson n'a rien d'un micro. « S'ils tournaient sur un microordinateur de bureau, les logiciels mettraient 2 heures pour répondre à une question » affirme-t-on chez IBM. Comme ses adversaires, Watson n'avait pas accès à Internet mais avait tout de même un avantage certain : IBM avoue que Watson disposait d'une antisèche équivalent à 200 millions de pages.


http://webdocs.cs.ualberta.ca/~chinook/


La stratégie dans le cas où celui qui prend le dernier objet gagne commence à l'identique, mais il faut viser S = 4 ou S = 2 au final.

8.2. Jeu avec stratégie gagnante : MarienbadCe jeu de société combinatoire abstrait, dont il existe plusieurs variantes, se joue avec des

graines, des dominos, des jetons, des cartes, des allumettes, ... Son origine est probablement très ancienne. Il appartient à la famille plus large des jeux de Nim.

Le jeu de Marienbad a été popularisé par le film d'Alain Resnais, L'année dernière à Marienbad, en 1961, au point d'en prendre le nom. Dans ce film, le héros gagne parties sur parties. Il prononce cette phrase à la portée symbolique : Je peux perdre, mais je gagne toujours...

Dans la version du film, il y a quatre rangées, avec respectivement 1, 3, 5, 7 allumettes et celui qui prend la dernière allumette perd. À chaque tour, le joueur prend le nombre d'allumettes qu'il veut, au moins une et dans une même rangée.

Stratégie gagnanteLa méthode repose sur le système binaire. La position de départ précisée par le

dessin ci-contre, s'analyse à l'aide des calculs suivants :

1 = 0 0 1 en binaire 3 = 0 1 1 " 5 = 1 0 1 " 7 = 1 1 1 "

Si on effectue les sommes des chiffres du binaire colonne par colonne en base dix, on trouve :

S = 2 2 4

Tous les chiffres de S sont pairs, le joueur qui débutera la partie perdra si son adversaire prend le soin de conserver cette propriété de S tant que ce nombre possède au moins deux chiffres. En fin de partie, il convient de choisir S = 3 ou S = 1 pour l'emporter.

Si on représente les différentes combinaisons de jeu, on voit qu'il existe un chemin (on parle de kernel : ensemble de nœuds) de coups gagnants. Ainsi, un joueur qui se trouve dans une situation gagnante et qui connaît l'astuce est sûr de gagner à la fin. Le joueur qui ne commence pas est dans le kernel (S pair) et est donc sûr de gagner quelles que soient les actions de l'adversaire (pourvu qu'il connaisse l'astuce, i.e., qu'il reste dans le kernel). Son adversaire n'a pas son destin entre ses mains. Ceci est vrai que le jeu soit classique (dernière allumette = perdu) ou non classique (dernière allumette = gagné).

Exercice 8.1Exercice 8.1Programmez le jeu de Marienbad avec une interface en ligne de commande (entrez les coups au

clavier selon un code que vous indiquerez).

8.3. Utilisation de la force brute : MastermindCe jeu de déduction se présente généralement sous la forme d'un plateau perforé de 10 rangées de

quatre trous pouvant accueillir des boules de couleurs. Il y a également des pions blancs et noirs utilisés pour donner des indications à chaque tour de jeu.

Un joueur commence par placer des boules sans qu'elles soient vues de l'autre joueur.L'autre doit trouver quelles sont les quatre boules, c'est-à-dire leurs couleurs et positions.Pour cela, à chaque tour, le joueur doit se servir de boules pour remplir une rangée selon l'idée

qu'il se fait des boules dissimulées. L'autre joueur indique alors :1. le nombre de boules de la bonne couleur bien placées en utilisant le même nombre de pions

noirs ;2. le nombre de boules de la bonne couleur, mais mal placées, avec les pions blancs.



Exercice 8.2Exercice 8.2Quelle est la combinaison gagnante ?

Comment l'ordinateur trouve la solution ?Ce jeu exige beaucoup de déduction et de concentration de la part d'un humain. Cependant, il est

facile pour un ordinateur de trouver la combinaison gagnante. Il va au début construire une liste de toutes les solutions possibles (il y en a kn, où n est les nombre d'emplacements et k le nombre de couleurs des boules). Il va ensuite éliminer de cette liste toutes les configurations impossibles en fonction des pions noirs et blancs, comme l'indique le schéma ci-dessous :

Au bout d'un certain nombre de tours, il ne restera plus qu'une solution possible.C'est ce qu'on appelle la force brute : on passe en revue toutes les possibilités et on élimine celles

qui ne vont pas.

Exercice 8.3Exercice 8.3Téléchargez et testez le programme de Sydney Barthe disponible sur le site compagnon. Pour

voir comment le programme joue, pressez alternativement les touches Conseiller puis Proposer.



8.4. Les trois piliers d'un jeu de stratégie

8.4.1. Interface graphiqueUne interface graphique (en anglais GUI pour graphical user interface) est un dispositif de

dialogue homme-machine, dans lequel les objets à manipuler sont dessinés sous forme de pictogrammes à l'écran, que l'usager peut opérer en imitant la manipulation physique de ces objets avec un dispositif de pointage, le plus souvent une souris. Ce type d'interface a été créé par Xerox en 1981 pour remplacer les interfaces en ligne de commande, puis popularisé par Apple avec l'ordinateur Macintosh quelques années plus tard.

Pour les jeux, cette interface graphique peut être plus ou moins élaborée. Elle est simple pour des jeux comme les dames ou les échecs, et très complexes pour des jeux en trois dimensions. Ci-dessous, l'interface graphique de Myth II :

8.4.2. Fonction d'évaluationComme son nom l'indique, cette fonction a pour but d'évaluer une position : un nombre très

grand sera l'indice d'une excellente position, tandis qu'un nombre très petit (généralement négatif, mais cela dépend de l'échelle choisie) traduira une position catastrophique.

Comment obtient-on une « bonne » fonction, c'est-à-dire une fonction qui traduit fidèlement la réalité ? Une fonction d'évaluation f est généralement une somme pondérée de la forme :

f(P) = a1·c1(P) + a2·c2(P) + ... + an·cn(P)

où les ai sont des poids (ai ∈ ℝ ) et les ci des caractéristiques d'une position P (par exemple, aux



échecs, le nombre de pions doublés, les pions occupant le centre, le nombre de fous pris à l'adversaire, le nombre de fous perdus, etc.). Trouver les caractéristiques d'un jeu n'est généralement pas chose facile, et les programmeurs ont souvent recours à des experts pour les y aider. Quant aux poids, qui traduisent le fait qu'une caractéristique est plus importante qu'une autre, leur ajustement fait plus appel à l'empirisme et à l'expérience du programmeur qu'à une méthode rigoureuse.

Une fonction d'évaluation peut aussi être « apprise » à l'aide d'un algorithme d'apprentissage à partir d'un ensemble de parties jouées.

8.4.3. Arbre de jeuxUn arbre de jeu consiste à représenter virtuellement, sous forme d'un arbre orienté, toutes les

positions que l'on peut atteindre à partir de celles du coup précédent. Selon le jeu, cet arbre devient gigantesque à partir de peu d'étages déjà. Aux échecs par exemple, les blancs ont le choix entre 20 coups (16 coups de pions et 4 coups de cavaliers) pour débuter la partie. Cela fait donc déjà 20 branches qui partent du sommet. Ensuite, les noirs ont aussi 20 coups à disposition. Cela fait déjà 400 positions possibles après 2 coups, puisque 20 branches partent des 20 positions précédentes !

Autant dire, qu'il est impossible de dessiner l'arbre de jeu complet, sauf pour des jeux très simples. Aussi doit-on élaguer l'arbre pour éliminer les positions manifestement mauvaises pour le joueur. Nous verrons plus tard comment s'y prendre.

Il est à noter qu'un arbre de jeu est une représentation virtuelle de tous les coups possibles. Dans le programme de jeu, il ne s'agira pas d'implémenter un arbre comme nous l'avions fait au chapitre 6.

Exercice 8.4Exercice 8.4Vous voyez ci-contre de tablier du jeu Pong Hau K'i. Chaque joueur bouge à

tour de rôle un des jetons de sa couleur sur la seule intersection disponible. Le but du jeu est de coincer l'adversaire.

Ce jeu est l'un des rares assez simples pour que l'on puisse dessiner l'arbre de jeu complet.

1. Combien y a-t-il de positions possibles ? Combien sont gagnantes ? 2. Dessinez l'arbre de ce jeu, en supposant que les noirs commencent. Que

constatez-vous ?3. Dessinez l'arbre de ce jeu, en supposant que les rouges commencent. Que constatez-vous?



Conseil : utilisez une feuille A3!Remarque : dessinez un graphe plutôt qu'un arbre, c'est-à-dire que vous pouvez relier une

position à une position déjà rencontrée, et ainsi « remonter » dans l'arbre.

8.4.4. Algorithme minimaxL'algorithme minimax est un algorithme qui s'applique à la théorie des jeux pour les jeux à deux

joueurs à somme nulle. Dans un jeu à somme nulle, la somme des gains de tous les joueurs est égale à 0. Par exemple, si l'on définit le gain d'une partie de tic-tac-toe comme 1 si on gagne, 0 si la partie est nulle et −1 si on perd, le tic-tac-toe est un jeu à somme nulle.

Cet algorithme amène l'ordinateur à passer en revue toutes les possibilités pour un nombre limité de coups et à leur assigner une valeur qui prend en compte les bénéfices pour le joueur et pour son opposant. Le meilleur choix est alors celui qui minimise les pertes du joueur tout en supposant que l'opposant cherche au contraire à les maximiser.

Fin d'une partie de Tic-tac-toe. Si les deux adversaires jouent juste (chemin rouge), la partie sera nulle (score de 0).

+1 indique une victoire des x.-1 indique une victoire des o.

Il existe différents algorithmes basés sur le minimax permettant d'optimiser la recherche du meilleur coup, en limitant le nombre de nœuds visités dans l'arbre de jeu. Le plus connu est l'élagage alpha-bêta. En pratique, l'arbre est souvent trop vaste pour pouvoir être intégralement exploré (comme par exemple pour le jeu d'échecs ou de go). Seule une fraction de l'arbre est alors explorée.

PrincipeL'algorithme minimax est très simple : on visite l'arbre de jeu pour faire remonter à la racine une

valeur (appelée « valeur du jeu ») qui est calculée récursivement. Soit p un nœud de l'arbre de jeu et f est une fonction d'évaluation de la position du jeu. Alors :

• valeur(p) = f(p) si p est une feuille de l'arbre • valeur(p) = MAX(valeur(O1), …, valeur(On)) si p est un nœud Joueur avec pour fils Oi• valeur(p) = MIN(valeur(O1), …, valeur(On)) si p est un nœud Opposant avec pour fils Oi



Exemple

Dans le schéma ci-dessus, les nœuds gris représentent les nœuds Joueur et les bleus les nœuds Opposant. Pour déterminer la valeur du nœud A, on choisit la valeur maximum de l'ensemble des nœuds B (A est un nœud Joueur). Il faut donc déterminer les valeurs des nœuds B qui reçoivent chacun la valeur minimum stockée dans leurs fils (les nœuds B sont Opposant). Les nœuds C sont des feuilles, leur valeur peut donc être calculée par la fonction d'évaluation.

Le nœud A prend donc la valeur 5. Le joueur doit donc jouer le coup l'amenant en B2. En observant l'arbre, on comprend bien que l'algorithme considère que l'opposant va jouer de manière optimale : il prend le minimum. Sans ce prédicat, on choisirait le nœud C1 qui propose le plus grand gain et le prochain coup sélectionné amènerait en B1. Mais alors on prend le risque que l'opposant joue C3 qui propose seulement un gain de 3.

En pratique, la valeur théorique de la position P ne pourra généralement pas être calculée. En conséquence, la fonction d'évaluation sera appliquée sur des positions non terminales. On considérera que plus la fonction d'évaluation est appliquée loin de la racine, meilleur est le résultat du calcul. C'est-à-dire qu'en examinant plus de coups successifs, nous supposons obtenir une meilleure approximation de la valeur théorique donc un meilleur choix de mouvement.

C'est de cette façon que l'on déterminera la force d'un programme : plus il descendra bas dans l'arbre, plus il sera redoutable (en supposant qu'il a une bonne fonction d'évaluation). La profondeur ne devra d'ailleurs pas forcément être la même pour tous les nœuds.

8.4.5. Élagage alpha-bêtaL'élagage alpha-bêta (alpha-beta pruning en anglais) est une technique très utilisée permettant de

réduire le nombre de nœuds évalués par l'algorithme minimax.L'algorithme minimax effectue en effet une exploration complète de l'arbre de recherche jusqu'à

un niveau donné, alors qu'une exploration partielle de l'arbre est généralement suffisante : lors de l'exploration, il n'est pas nécessaire d'examiner les sous-arbres qui conduisent à des configurations dont la valeur ne contribuera sûrement pas au calcul du gain à la racine de l'arbre. L'élagage α-β nous permet de réaliser ceci.

Plus simplement, l'élagage α-β évite d'évaluer des nœuds dont on est sûr que leur qualité sera inférieure à un nœud déjà évalué, il permet donc d'optimiser grandement l'algorithme minimax sans en modifier le résultat.



PrincipeOn prend α et β appartenant au domaine d'arrivée de la fonction d'évaluation tel que α < β. On

définit la fonction AlphaBeta ainsi :• AlphaBeta(P, α, β)=g(P) si P est une feuille de l'arbre et g la fonction d'évaluation du nœud• AlphaBeta(P, α, β)=min(β, max(−AlphaBeta(Oi, −β, −α))) où les Oi sont les fils du nœud P

On appelle fenêtre α-β le couple (α, β) où α et β sont les deux paramètres d'appel de la fonction. Les nœuds élagués sont ceux qui seraient appelés avec une fenêtre tel que α ≥ β. Il existe 3 types de nœuds ne pouvant donc pas être élagués :

• Nœud de type 1 : fenêtre d'appel : (−∞, +∞)• Nœud de type 2 : fenêtre d'appel : (−∞, β) avec β ≠ +∞• Nœud de type 3 : fenêtre d'appel : (α, +∞) avec α ≠ −∞

Le schéma ci-dessous présente les deux types de coupures possibles. Les nœuds Min sont représentés par un rond bleu et les nœuds Max par un carré gris. Rappel : les nœuds Min prennent la valeur minimum de leurs fils (et respectivement maximum pour les nœuds Max).

Coupure Alpha : le premier fils du nœud Min V vaut 4 donc V vaudra au plus 4. Le nœud Max U prendra donc la valeur 5 (maximum entre 5 et une valeur inférieure ou égale à 4).

Coupure Beta : le premier fils du nœud Max V vaut 4 donc V vaudra au minimum 4. Le nœud Min U prendra donc la valeur 3 (minimum entre 3 et une valeur supérieure ou égale à 4).

Voici le résultat de l'élagage sur l'arbre ci-dessous déjà étiqueté avec les valeurs d'un minimax.

Minimax avec élagage alpha-bêta

Trois coupures ont pu être réalisées :1. Le nœud MIN vient de mettre à jour sa valeur courante à 4. Celle-ci, qui ne peut que

baisser, est déjà inférieure à α=5, la valeur actuelle du nœud MAX précédent. Celui-ci cherchant la valeur la plus grande possible, ne la choisira donc de toute façon pas.

2. Le nœud MIN vient de mettre à jour sa valeur courante à 6. Celle-ci, qui ne peut que baisser, est déjà égale à α=6, la valeur actuelle du nœud MAX précédent. Celui-ci cherchant



une valeur supérieure, il ne mettra de toute façon pas à jour sa valeur que ce nœud vaille 6 ou moins.

3. Le nœud MIN vient de mettre à jour sa valeur courante à 5. Celle-ci, qui ne peut que baisser, est déjà inférieure à α=6, la valeur actuelle du nœud MAX précédent. Celui-ci cherchant la valeur la plus grande possible, ne la choisira donc de toute façon pas.

Exercice 8.5Exercice 8.51. Remplissez les valeurs des nœuds de l'arbre ci-dessous en suivant l'algorithme minimax.2. Refaites ensuite l'exercice avec l'élagage alpha-bêta.

Dans le Reversi original, il n'y a aucun pion posé en début de partie, les ouvertures sont donc libres. Une partie d'Othello débute avec 4 pions placés au centre.

8.5. OthelloOthello est basé sur le jeu Reversi qui a été inventé en 1883 par l'Anglais Lewis Waterman, et

acquis une popularité considérable en Angleterre à la fin du XIXe siècle. Le jeu d'Othello sous sa forme actuelle a été commercialisé pour la première fois au Japon en 1971.

C'est un jeu de stratégie à deux joueurs : Noir et Blanc. Il se joue sur un damier vert de 64 cases, 8 sur 8.

Ces joueurs disposent de 64 pions bicolores, noirs d'un côté et blancs de l'autre. Par commodité, chaque joueur a devant lui 30 pions (2 de sa couleur sont déjà placés sur le plateau au début de la partie, comme montré sur le schéma ci-dessous).

Un pion est noir si sa face noire est visible et blanc si sa face blanche est sur le dessus.

But du jeu

Avoir plus de pions de sa couleur que l'adversaire à la fin de la partie.Celle-ci s'achève quand aucun des deux joueurs ne peut plus jouer de coup légal.

La pose d'un pion

À son tour de jeu, le joueur doit poser un pion de sa couleur sur une case vide du plateau, adjacente à un pion adverse. En posant son pion, il doit encadrer un ou plusieurs pions adverses entre



le pion qu'il pose et un pion de sa couleur, déjà placé sur le plateau, que ce soit sur une ligne horizontale, verticale ou diagonale.

Les pions encadrés sont alors retournés en pions de couleur inverse. Les pions ne sont jamais retirés du plateau, ni déplacés d'une case à l'autre.

Si un joueur ne peut pas poser de pions, il passe son tour.

6 premières positions d'une partie d'Othello. La position initiale du jeu est celle en haut à gauche et c'est le joueur noir qui débute la partie. Le premier coup de noir est 'd3', la réplique de blanc est 'e3', puis noir joue en 'f4' et blanc en 'e5', et le dernier coup joué par noir est 'd6'.

Force des programmesDepuis 1995 et le programme Logistello de Michael Buro, l'ordinateur est beaucoup plus fort que

l'humain au jeu d'Othello.Les programmes d'Othello sont relativement simples à écrire. Aussi est-il devenu classique de

développer un programme d'Othello pendant ses études d'informatique.

http://ow.ly/5iIy8

8.5.1. Analyse du programme Othello-pyNous allons analyser un programme jouant à Othello2. Il a été francisé et modifié par l'auteur

pour être compatible avec Python 3. Allez sur le site compagnon pour télécharger cette version remaniée.

Le programme se compose de quatre modules :• « minimax »

• explore l'arbre de jeu • « othello »

• implémente le jeu Othello (coups légaux, retournement des pions, fin de partie, etc.)

• contient la fonction d'évaluation (« edge_eval »)• « game2 » :

• gère la partie elle-même (tour de jeu, temps de réflexion, gain de la partie, etc.)• permet de tester des parties ordinateur contre ordinateurs• peut être exécuté sans passer par l'interface graphique

• « othello_gui » • est l'interface graphique• à exécuter pour qu'un humain joue contre l'ordinateur

2 Voir [10]


http://ow.ly/5iIy8


Exercice 8.6Exercice 8.61. Téléchargez ces quatre modules et analysez-les attentivement. En particulier,

• comment fonctionne l'élagage alpha-bêta dans le module « minimax » ?• comment est calculée la fonction d'évaluation ?

2. Modifiez la fonction d'évaluation pour tenter de rendre le programme encore plus fort. Testez votre fonction comme indiqué dans les commentaires en bas du module « game2 ».

Sources[1] Wikipédia, « Intelligence artificielle », <http://fr.wikipedia.org/wiki/Intelligence_artificielle>

[2] Wikipédia, « Programme d'échecs », <http://fr.wikipedia.org/wiki/Programme_d'échecs>

[3] Wikipédia, « Backgammon », <http://fr.wikipedia.org/wiki/Backgammon>

[4] Wikipédia, « Jeu de Go », <http://fr.wikipedia.org/wiki/Jeu_de_go>

[5] Wikipédia, « Jeu de Marienbad », <http://fr.wikipedia.org/wiki/Jeu_de_Marienbad>

[6] Barthe Sidney, Mastermind. Un jeu compliqué ?, Travail de maturité, février 2010

[7] Wikipédia, « Algorithme Minimax », <http://fr.wikipedia.org/wiki/Algorithme_minimax>

[8] Wikipédia, « Elagage alpha-bêta », <http://fr.wikipedia.org/wiki/élagage_alpha-bêta>

[9] Fédération française d'Othello, <http://www.ffothello.org/>

[10] Othello-py, <http://code.google.com/p/othello-py/>


http://code.google.com/p/othello-py/

http://www.ffothello.org/

http://fr.wikipedia.org/wiki/%C3%A9lagage_alpha-beta

http://fr.wikipedia.org/wiki/Algorithme_minimax

http://fr.wikipedia.org/wiki/Jeu_de_Marienbad

http://fr.wikipedia.org/wiki/Jeu_de_go

http://fr.wikipedia.org/wiki/Backgammon

http://fr.wikipedia.org/wiki/Programme_d'%C3%A9checs

http://fr.wikipedia.org/wiki/Intelligence_artificielle


http://ow.ly/3pd8f

Chapitre 9Bases de données

Une base de données (BD) est un ensemble structuré d'informations. Dans le langage courant, le terme peut désigner toute source importante de données telle qu'une encyclopédie. Dans le domaine de l'informatique, c'est un ensemble d'informations regroupées sous la forme d'enregistrements stockés sur un système de fichiers structurés et organisées de manière à pouvoir être facilement manipulées.

L'organisation logique des données se fait selon un modèle de données et la structure physique des fichiers comporte des index destinés à accélérer les opérations de recherche et de tri. Le modèle de données relationnel est aujourd'hui le plus utilisé parce qu'il permet l'indépendance entre la structure physique et l'organisation logique des données.

Le logiciel qui manipule les bases de données est appelé système de gestion de base de données (SGBD). Il permet d'organiser, de contrôler, de consulter et de modifier la base de données. Les opérations sont parfois formulées dans un langage de requête tel que SQL, qui est le plus connu et employé pour les modèles relationnels.

9.1. Un exemple pour tout expliquer rapidementReplongeons-nous avant les années 1980, lorsque la téléphonie mobile n'existait pas. Nous allons

imaginer un opérateur de téléphonie qui veut créer une base de données pour gérer ses clients. Les clients peuvent obtenir plusieurs numéros de téléphone auprès de cet opérateur. Pour chacun de ces numéros, l'opérateur enregistrera les informations nécessaires pour établir une facture mensuelle détaillée.

Quelles sont ces données nécessaires ? Il faudra tout d'abord identifier de manière non équivoque le client : on enregistrera donc son nom, son prénom et son adresse. On stockera aussi le numéro de téléphone qu'il a utilisé (rappelons qu'il peut en avoir plusieurs ; on fera une facture par numéro). Il faudra aussi connaître, pour calculer les prix de la communication, le numéro appelé, la date et l'heure de l'appel (pour établir la facture détaillée) ainsi que la durée de l'appel. Enfin, comme le prix de l'appel peut varier selon l'heure et le numéro appelé, on mentionnera le tarif appliqué.

9.1.1. Première approche : un tableurUne première idée pour implémenter une base de données consiste à utiliser un tableur. En effet,

une base de données « plate » peut se voir comme un simple tableau : les colonnes représenteront des champs (nom, prénom, numéro de téléphone, etc.), et les lignes des enregistrements (ici des appels). Par exemple, voici un extrait de cette base de données :

Didier Müller 9-1 Mars 2012

http://ow.ly/3pd8f

Bases de données

Nom Prénom Adresse Numéro de tél.

No appelé Date et heure de l'appel

Durée de l'appel (sec)

Tarif (CHF/min)

Müller Didier Petit-Chêne 32900 Porrentruy

0324660010 00333246634217 10.2.201014:32

455 0.70


0324660010 0324711230 17.2.201018:37

62 0.20


0324669987 0324711230 23.2.20109:21

145 0.20

Müller Didier Grand-Rue 492800 Delémont

0324221022 0214537124 12.2.201019:01

302 0.10

... ... ... ... ... ... ...

L'avantage de cette méthode est sa simplicité : tout ce qui concerne un appel tient sur une ligne, et tous les appels sont répertoriés dans une table. Cette approche a aussi des inconvénients :

1. Les informations sont redondantes : l'adresse du client apparaît plusieurs fois, encombrant inutilement la mémoire. Il aurait été plus judicieux d'avoir une autre table où l'on aurait enregistré les coordonnées des clients une fois pour toutes.

2. Pour identifier un client, on a besoin de trois champs. Il aurait été plus simple d'associer à chaque client un numéro de client unique (ce que toutes les entreprises font).

3. Si un utilisateur change d'adresse, il faut reporter ce changement sur chaque ligne où il apparaît, sous peine d'avoir une table incohérente.

4. Un tableur n'est tout simplement pas fait pour gérer une grande base de données.

9.1.2. Deuxième approche : base de données relationnelleUne autre solution est d'utiliser plusieurs tables reliées entre elles. On parle alors de base de

données relationnelle. La liaison de différentes tables se fera en utilisant un logiciel de gestion de bases de données (SGBD).

Reprenons l'exemple de l'entreprise de téléphonie. On va utiliser trois tables au lieu d'une : la première contiendra les coordonnées des clients, la seconde les numéros de téléphone des clients, et la troisième la liste des appels.

Id_client Nom Prénom Adresse

156 Müller Didier Grand-Rue 492800 Delémont

10234 Müller Didier Petit-Chêne 32900 Porrentruy

... ... ... ...

Table des clients

Numéro Id_client

0324221022 156

0324660010 10234

0324669987 10234

... ...

Table des numéros

La table des numéros permet de faire la liaison entre un abonné et son ou ses numéros de téléphone. Elle est indispensable du fait qu'un abonné peut avoir plusieurs numéros de téléphone différents.

Si cela n'avait pas été le cas, on aurait simplement pu ajouter un champ « numéro » à la table des clients. Ce champ aurait alors pu être utilisé comme identifiant et remplacer le champ « Id_Client ».



Id_appel Numéro appelant

No appelé Date et heure de l'appel

Durée de l'appel (sec)

Tarif (CHF / min)

123465 0324660010 00333246634217 10.2.201014:32

455 1.00

145674 0324660010 0324711230 17.2.201018:37

62 0.20

162346 0324669987 0324711230 23.2.20109:21

145 0.20

124369 0324221022 0214537124 12.2.201019:01

302 0.10

... ... ... ... ...

Table des appels

Cette manière de faire est moins lisible au premier coup d'œil : il faut par exemple consulter deux tables pour connaître le propriétaire d'un numéro de téléphone. Mais cet inconvénient est vite balayé par les avantages :

1. Les informations ne sont plus redondantes : par exemple, l'adresse d'un client apparaît une seule fois et est donc facilement modifiable.

2. Un client est identifié par un numéro, ce qui évite des confusions.3. Il est très facile de tirer la liste des clients, puisqu'ils sont tous rassemblés dans une table.

etc.

9.2. Les bases de données relationnellesC'est l'article d'Edgar Frank Codd (1923-2003) « A Relational Model of Data for Large Shared

Data Banks », CACM 13, No. 6, June 1970 qui fonde le modèle relationnel, mais une première description de ce modèle avait déjà été publiée l'année précédente dans un rapport technique d'IBM : « Derivability, Redundancy, and Consistency of Relations Stored in Large Data Banks », IBM Research Report RJ599.

TablesDans les bases de données relationnelles, une table est un ensemble de données organisées sous

forme d'un tableau où les colonnes correspondent à des champs et les lignes à des enregistrements, également appelés entrées.

La notion de table est apparue dans les années 1970 chez IBM avec l'algèbre relationnelle qui est une théorie mathématique en relation avec la théorie des ensembles. Cette théorie a pour but de clarifier et de faciliter l'utilisation d'une base de données.

Conception d'une tableLors de la conception d'une base de données relationnelle, il est important de clairement définir

toutes les tables qui la composeront et les différentes relations qui les lient, de manière à pouvoir dresser le schéma conceptuel qui permettra de décrire le fonctionnement de la base de données avant de la mettre « physiquement » en place.

On distinguera les tables courantes, qui contiendront divers champs contenant des informations, et les tables de liaison, qui feront les liens entre deux tables courantes.

Contenu d'une tablePar nature, chaque colonne d'une table, également nommé « champ », doit contenir des données

d'un même type et ce champ doit être nommé. Chaque table est l'implémentation physique d'une relation entre les différents champs. Chaque correspondance est définie par une ligne de la table. Il y a certaines règles à respecter, notamment le fait qu'il faille mettre un identifiant pour chaque enregistrement dans la table. Il y a deux possibilités :

• Mettre un identifiant qui s'auto-incrémente au fur et à mesure des données entrées (par exemple « Id_appel » dans la « table des appels »)

• Choisir un identifiant unique (par exemple « Id_client » dans la « table des clients »).


Bases de données

Travail sur une tableIl y a deux niveaux de travail sur une table :• un niveau de définition des données d'une table, qui permet de définir, lier, et contraindre les

données via un langage de définition de données ;• un niveau de manipulation des données d'une table, qui permet d'ajouter, supprimer,

rechercher des données via un langage de manipulation de données Actuellement, le langage standardisé pour travailler sur les tables est le SQL. Il est utilisé avec

quelques variantes sur la plupart des systèmes de gestion de bases de données. Nous en reparlerons au § 9.5.

9.3. Modèle entité-associationLe modèle entité-association (aussi appelé « modèle entité-relation ») est un type de schéma

conceptuel très utilisé pour les bases de données, notamment les bases de données relationnelles. Il a été inventé par Peter Pin-Shan Chen en 1975 et est destiné à clarifier l'organisation des données dans les bases de données relationnelles en notifiant :

- les entités

• Ce sont des objets concrets que l'on peut identifier (client, livre, individu, voiture, etc.).• On peut représenter un ensemble d'entités de la réalité par une entité type (un client pour

l'ensemble des clients). • Ces entités sont caractérisées par leurs attributs (pour un client : nom, prénom, adresse, ...).

Parmi ces attributs, on définit un identifiant qui va permettre de caractériser de façon unique l'entité dans l'ensemble (un numéro de client).

- les relations entre les entités

• Elles représentent les liens existant entre une ou plusieurs entités. • Elles sont caractérisées par un nom, une propriété d'association et éventuellement des

attributs.

- le degré de relation et cardinalités

• Le degré de la relation (ou dimension de la relation) est le nombre d'entités qui sont impliquées dans cette relation.

• La cardinalité (d'une entité par rapport à une relation) exprime le nombre de participations possibles d'une entité à une relation. Comme c'est un nombre variable, on note la cardinalité minimum (0 ou 1) et maximum pour chaque entité. Dans notre exemple, un abonné peut avoir de 1 à N numéros de téléphone, mais le numéro de téléphone n'appartient qu'à un client ou aucun client (numéro pas encore attribué ou plus attribué). Il ne peut pas avoir 0 numéro, car dans ce cas il ne serait plus client de l'opérateur.

9.3.1. Représentation graphique• Les entités sont représentées dans des rectangles et s'écrivent en lettres majuscules. • L'identifiant d'une entité (aussi appelé « clé primaire ») est le premier attribut cité et est

souligné. Les autres attributs sont placés à la suite. • Les relations sont placées dans des losanges avec leurs attributs éventuels. • Les cardinalités sont placées à côté de l'entité qu'elles caractérisent.

9.3.2. Démarche de conceptionVoici une méthode possible pour réaliser un schéma entité-association :1. établir la liste des entités ;2. déterminer les attributs de chaque entité en choisissant un identifiant :3. établir les relations entre les différentes entités et définir les cardinalités.



9.3.3. ExempleReprenons l'exemple de notre opérateur de téléphonie fixe.1. Il y a 3 entités : les clients, les numéros de téléphone et les appels.2. Les attributs :

- Pour les clients : id, nom, prénom, adresse.- Pour les numéros de téléphone : le numéro.- Pour les appels : le numéro appelé, la date, la durée et le tarif.

3. Les relations et les cardinalités :- Un client possède 1 ou plusieurs numéros.- Un numéro appartient à 0 ou 1 client.- Un numéro peut faire 0 ou plusieurs appels.- Un appel est fait depuis 1 et un seul numéro.

Représentation graphique

On peut classer les relations en 3 types selon leur cardinalité maximale :• les relations un à un (par exemple 1:1 – 0:1)• les relations un à plusieurs (c'est le cas des deux relations ci-dessus)• les relations plusieurs à plusieurs (par exemple 0:N – 1:N)

Exercice 9.1Exercice 9.1On veut créer une petite base de données permettant de garder le contact avec nos copains de

classe. On supposera qu'ils sont tous domiciliés en Suisse. On veut stocker les renseignements suivants : nom, prénom, sexe, date de naissance, numéro de téléphone, rue, numéro postal, ville et canton.

Réalisez un schéma entité-association en suivant la démarche décrite au § 9.3.2.

Exercice 9.2Exercice 9.2On veut créer une base de données permettant de gérer les clients étrangers d'une entreprise et les

pays de ces clients. La table des clients sera simplifiée et comportera leur nom, leur prénom, le code de leur pays de résidence et le solde de leur compte, dans la monnaie du pays.

On veut aussi que les clients aient la possibilité de faire des réclamations et que la base de données gère toutes ces réclamations pour chacun des clients.



Bases de données

Exercice 9.3Exercice 9.3Une école veut informatiser ses listes de classe. Une classe est formée d'élèves (toujours les

mêmes et un élève n'appartient qu'à une seule classe). Il y a un maître de classe par classe. Un prof peut enseigner plusieurs disciplines.


9.4. Traduction du schéma conceptuel en un modèle relationnel

Les règles principales de transformation d'un schéma conceptuel entité-association en un schéma relationnel sont :

Règle IToute entité est traduite en une table relationnelle dont les caractéristiques sont les suivantes :• le nom de la table est le nom de l'entité ; • la clé de la table est l'identifiant de l'entité ; • les autres attributs de la table forment les autres colonnes de la table.

Règle IIToute relation binaire plusieurs à plusieurs est traduite en une table relationnelle dont les

caractéristiques sont les suivantes : • le nom de la table est le nom de la relation ; • la clé de la table est formée par « l'addition » des identifiants des entités participant à la

relation ; • les attributs spécifiques de la relation forment les autres colonnes de la table.



Règle IIIToute relation binaire un à plusieurs est traduite :1. soit par un report de clé (voir schéma ci-dessous) : l'identifiant de l'entité participant à la

relation côté N est ajoutée comme colonne supplémentaire à la table représentant l'autre entité. Cette colonne est parfois appelée clé étrangère. Le cas échéant, les attributs spécifiques à la relation sont eux aussi ajoutés à la même table ;

2. soit par une table spécifique dont les caractéristiques sont les suivantes :• le nom de la table est le nom de la relation ; • la clé de la table est l'identifiant de l'entité participent à la relation côté 1 ; • les attributs spécifiques de la relation forment les autres colonnes de la table.

Règle IVToute relation binaire un à un est traduite, au choix, par l'une des trois solutions suivantes :• choix 1 : fusion des tables des entités qu'elle relie ; • choix 2 : report de clé d'une table dans l'autre (voir ci-dessous); • choix 3 : création d'une table spécifique reliant les clés des deux entités.


Bases de données

Exercice 9.4Exercice 9.4Transformez le schéma entité-association de l'exercice 9.1 en un modèle relationnel.



9.5. Le langage SQLLe modèle relationnel de Codd a été rapidement admis comme modèle définitif pour les bases de

données. Un langage, Structured English Query Language (langage d'interrogation structuré en anglais) a été développé par IBM pour le mettre en œuvre.

La première version de SQL a été développée chez IBM en 1970 par Donald Chamberlain et Raymond Boyce.

En 1979, Relational Software, Inc. (actuellement Oracle Corporation) présenta la première version commercialement disponible de SQL (Structured Query Language), rapidement imité par d'autres fournisseurs.

SQL se décompose en 5 parties, à savoir :• Ordres LDD (langage de définition des données, ou DDL, Data Definition Language) :

permet de modifier la structure de la base de données • Ordres LMD (langage de manipulation des données, ou DML, Data Manipulation

Language) : permet de consulter / modifier le contenu de la base de données • Ordres LCD (langage de contrôle des données, ou DCL, Data Control Language) : permet

de gérer les privilèges, c'est-à-dire les utilisateurs et les actions qu'ils peuvent entreprendre • Ordres LCT (langage de contrôle des transactions, ou TCL, Transaction Control

Language) : permet de gérer les transactions, c'est-à-dire rendre atomique divers ordres enchaînés en séquence

• SQL procedural : PSM (Persistent Stored Module), CLI (Call Level Interface), Embedded SQL, … qui est un ensemble d'outils pour que SQL s'interface avec des langages hôtes.

Nous ne verrons ici que des exemples simples pour les deux premières parties.

9.5.1. Exemples d'ordres LDD

Création d'une table : CREATE TABLECREATE TABLE table1 (colonne1 INTEGER, colonne2 INTEGER, colonne3 DATE, colonne4 DATE);

Modification d'une table : ALTER TABLEAjouter une colonne

ALTER TABLE table1 ADD COLUMN colonne5 INTEGER NULL;

Supprimer une colonne

ALTER TABLE table1 DROP COLUMN colonne5;

Suppression d'une table : DROP TABLEDROP TABLE table1;



Il existe d'autres commandes comme « GROUP BY » ou « HAVING ».

Comme souvent en informatique, mieux vaut éviter les caractères accentués...

Il existe cinq fonctions utilisables avec SELECT :

COUNT, SUM, AVG, MIN et MAX.

9.5.2. Exemples d'ordres LMD

Recherche simple de lignes dans une tableSELECT {liste_colonnes}FROM {TABLES}WHERE {conditions}ORDER BY {expressions}

Afin de rendre les choses plus concrètes, nous utiliserons les deux tables « employes » et « departements » ci-dessous :

employes

id nom prenom telephone id_departement statut salaire

departements

id nom id_chef

Trouver le prénom et le numéro de téléphone de tous les « Dupont » dans la table « employes » :

SELECT prenom, telephone FROM employesWHERE nom = "Dupont";

Trouver le prénom et le téléphone des « Dupont » ou « Dupond » dans la table « employes » :SELECT prenom, telephone SELECT prenom, telephoneFROM employes ou FROM employesWHERE nom in ("Dupont","Dupond"); WHERE nom = "Dupont"

OR nom = "Dupond";

Compter le nombre de « Dupont » dans la table « employes » :

SELECT COUNT(*)FROM employesWHERE nom = "Dupont";

Compter le nombre d'employés appartenant au service « comptabilité » :

SELECT COUNT(*)FROM employes, departementsWHERE departements.nom = "comptabilité"

AND departements.id = employes.id_departement;

Trouver le nom de tous les stagiaires dans la table « employes » et les trier par nom.

SELECT nomFROM employesWHERE statut="stagiaire"ORDER BY nom;

Trouver tous les employés touchant plus de 1500 CHF par mois classés par salaire et afficher tous les champs (*) :

SELECT *FROM employesWHERE salaire > 1500ORDER BY salaire;


Bases de données

HAVING a le même rôle que WHERE, mais est toujours couplé avec GROUP BY.

Afficher les statuts et le salaire moyen des employés par statut, si le salaire moyen dépasse 5000 CHF (en omettant le dernière ligne du code ci-dessous, on affichera tous les statuts).

SELECT statut, AVG(salaire)FROM employesGROUP BY statutHAVING AVG(salaire) > 5000;

Ajout d'une ligneAjouter un dénommé « Martin » comme chef de la comptabilité.

INSERT INTO departements (id, nom, id_chef) VALUES ("compta", "comptabilité", "Martin");

Ajout de données à partir des lignes d'une autre table :INSERT INTO TABLE1 (colonne1, colonne2, colonne3) SELECT colonne10, colonne20, (colonne30 + colonne40) / 2 FROM TABLE2;

Modification de lignesChanger le statut de l'employé « Durand » :

UPDATE employesSET statut="collaborateur"WHERE nom = "Durand";

Suppression d'une ligneSupprimer tous les employés nommés « Alpha » :

DELETE FROM employesWHERE nom = "Alpha";

Exercice 9.7Exercice 9.7Avec les tables « employes » et « departements » ci-dessus, faites les opérations suivantes :1. supprimer le département « culture » ;2. trouver le statut de « Jean Némare » ;3. modifier le numéro de téléphone de « Jean Némare » : le nouveau numéro est 0325641353 ;4. ajouter un département « réclamations », avec pour chef de département « Jean Némare » ;5. supprimer le département dont le chef s'appelle « Haenni » ;6. trouver la somme (SUM) des salaires des employés pour chaque département ;7. lister les noms de tous les chefs de départements, triés par nom de famille.

http://ow.ly/4ufN1

Il existe des équivalents pour Linux (LAMP) et Mac OS (MAMP).

9.6. EasyPHP et mySQLRemarque : les explications ci-dessous correspondent à la version 5.3.0 sortie en 2011. Il est

possible que l'interface ait un peu changé depuis.

9.6.1. Un outil indispensable : EasyPHPEasyPHP est un environnement de travail packagé comprenant le serveur web Apache, le système

de gestion de bases de données MySQL et le support du langage PHP. Il est fourni avec phpMyAdmin, une interface permettant de manipuler très facilement les enregistrements de la base de données.


http://ow.ly/4ufN1


Site officiel : www.easyphp.orgInstallez cet environnement sur votre PC personnel ou votre clé USB.

Démarrer EasyPHPSi vous ne l'avez pas encore installé, téléchargez le logiciel GNU/GPL depuis le site

www.easyphp.org. Dans Démarrer>Programmes, sélectionnez EasyPhp. Si vous démarrez depuis votre clé USB, un fenêtre apparaîtra pour vous demander si vous voulez régénérer les fichiers de configuration. Répondez Oui.

Une petite icône en forme de « e » noir avec un carré rouge apparaît en bas à droite, à côté de l'horloge, signalant le démarrage du serveur PHP-mysql. Une petite fenêtre doit également apparaître vous signalant le démarrage des serveurs. Cette fenêtre permet de démarrer ou d'arrêter Apache (le serveur PHP) et MySQL (la base de donnée) à l'aide des boutons.

Après avoir cliqué sur l'icône avec le bouton droit de la souris, sélectionnez administration. Ceci va ouvrir la fenêtre d'EasyPHP-administration. Cliquez alors sur :

La fenêtre qui apparaît va vous permettre de créer et gérer les bases de données en mode local. Elle ressemble à celle ci-dessous.

La partie de gauche (en bleu) permet d'administrer les bases de données existantes sur votre PC.Celle de droite permet de créer une nouvelle base de donnée ou de gérer lestables existantes si

elles sont sélectionnées à gauche.

Créer une baseCommençons par créer une base de données que nous appellerons « copains » (laissez le type en

« Interclassement » par défaut). C'est cette base qui contiendra les différentes tables.

Créer une première tableLes tables intègrent les informations brutes, non traitées. Nous allons créer deux tables : la table

« personne » qui contiendra les informations relatives aux copains eux-mêmes et une table « lieu » qui contiendra des données sur leur lieu de domicile.


http://www.easyphp.org/

http://www.easyphp.org/

Bases de données

Entrez le nom de la table « personne », avec 8 champs. La fenêtre suivante va permettre de personnaliser nos champs. Vous devez obligatoirement entrer toutes les données.

Vous obtiendrez une liste de champs que vous devrez remplir comme ci-dessous :

• Le nom du champ ne peut être nul, ni comporter de caractères accentués, espaces, -, etc. Par contre, il accepte _.

• Le type de champ est sélectionné dans une liste de choix. Pour l'instant, sélectionnons VARCHAR qui correspond à du texte.

• la Taille/valeurs nous permet de déterminer la taille maximum des données à rentrer dans les champs.

• Interclassement représente le jeu de caractères par défaut si vous ne sélectionnez rien (préférable). Sinon vous pouvez sélectionner Latin1_swedish_ci. Si le jeu de caractère n'est pas démarré dans PHPMYADMIN, vous recevrez néanmoins un code d'erreur.

• L'attribut peut être rien, unsigned ou Unsigned zerofill. Les 2 dernières valeurs s'utilisent uniquement pour des types de champs spéciaux.

• Null permet de définir si le champ peut être null (vide) ou non. • Défaut permet de donner une valeur par défaut au champ.

Les types de champsNous venons de créer deux champs. Nous avons choisi le type VARCHAR (type caractère à taille



variable). Les tableaux ci-après montrent les autres types disponibles sous MYSQL.

Les champs de types caractères CHAR Chaîne de caractères fixe, nombre de caractères

obligatoires. Les caractères non inclus seront remplacés par des espaces.

255 car. max taille obligatoire

VARCHAR Chaîne de caractères de longueur variable 255 car. max. taille maximum obligatoire

TINYBLOB Petite zone de texte, sensible à la casse 255 car. max.

TINYTEXT Petite zone de texte, insensible à la casse 255 car. max.

BLOB Zone de texte standard (mais accepte toute sortes de données comme des images), sensibles aux majuscules / minuscules

65K car. max

TEXT Zone de texte standard (mais accepte toute sortes de données comme des images), insensible à la casse

65K car. max

MEDIUMBLOB Zone de texte moyenne, différencie majuscule /minuscule

16 millions car. max.

MEDIUMTEXT Zone de texte moyenne, insensible à la casse 16 millions car. max.

16 millions car. max.

LONGBLOB Grande zone de texte, différencie majuscule / minuscule

4 milliards car. max.

LONGTEXT Grande zone de texte, ne différentie pas majuscule / minuscule

4 milliards car. max.

ENUM Liste de choix 65535 valeurs max.

SET Liste de choix multiple 64 valeurs max.

Les types CHAR et CHARVAR ne différencie pas les majuscules et les minuscules. Pour rendre ces données sensibles à la casse, utilisez l'option [Binary] lors de la création du champs. Les variables de type TEXT sont insensibles à la casse, les variables de type BLOG les différencie.

Les champs numériquesTINYINT Entier très petit 256 valeurs différentes, de -128 à +127

ou 0 à 255 (1 octet)

SMALLINT Entier petit 65.536 valeurs différentes (2 octets)

MEDIUMINT Entier moyen 16.777.216 valeurs différentes (3 octets)

INT Entier standard 4.294.967.296 valeurs différentes (4 octets)

BIGINT Entier grand 8 octets

FLOAT Décimal de simple précision 4 octets

DOUBLE, REAL Décimal de double précision 8 octets

DECIMAL, NUMERIC Décimal sous forme de chaîne variable

Pour les champs de type entier, vous pouvez utiliser l'option Signed (par défaut) pour déterminer des valeurs négatives ou positives ou Unsigned (uniquement des valeurs positives). L'option ZEROFILL assure l'affichage des zéros.


Bases de données

Dates et heuresDATE Date. Par exemple 2008-03-06, format anglophone 3 octets

TIME Heure. Par exemple 10:25:59 3 octets

DATETIME Date et heure. Par exemple 2006-03-06 10:25:59 8 octets

TIMESTAMP Date et heure sans les séparations, par exemple 20060306102559. Attention, le format a évolué avec les versions d'où un risque d'erreur en changeant d'hébergement Internet.

4 octets

YEAR Année, exemple 2011 1 octet

Après avoir pressé "Sauvegarder", vous verrez apparaître :

• permet de déterminer si le champ est ou non une clé primaire. Dans ce cas, la valeur du champ sera unique dans la table. Aucun enregistrement n'aura la même valeur dans ce champ, les tris sont également plus rapides

• index permet d'augmenter les vitesses de traitement (tri) dans la table. La clé primaire est également un index.

• unique permet de spécifier que le contenu est unique dans l'ensemble du champ. Contrairement à l'index, elle n'augmente pas la vitesse de traitement.

• permettent d'indexer des textes complets. Cette possibilité ralentit la table pour de longs champs

• permet d'éditer (modifier) la table. • Le bouton permet de supprimer le champ.

Cliquez sur dans la ligne id. Ce sera notre clé primaire, un identificateur qui désignera une personne d'une manière unique. Dans notre cas, ce sera simplement un nombre. Vous obtiendrez l'image suivante où vous constaterez que id est maintenant souligné.



Créer une deuxième tablePour créer une deuxième table, cliquez sur copains dans la partie gauche de la fenêtre. Nous

allons créer une table "lieu" avec 3 champs.

Voici la fenêtre suivante et la manière de remplir les champs :


Bases de données

Vous obtiendrez finalement :

Cliquez encore sur dans la ligne no_postal. pour définir la clé primaire.

Insérer des donnéesPour insérer des données, rien de plus simple. Choisissez d'abord la table dans la marge de

gauche (lieu ou personne), puis cliquez sur l'onglet Insérer. Remplissez ensuite les champs puis pressez le bouton Exécuter.

Faire des requêtesCliquez sur les onglets Rechercher ou SQL.

Exercice 9.8 (copains de classe, réalisation et recherches)Exercice 9.8 (copains de classe, réalisation et recherches)

Entrée des donnéesEntrez dans la base de données que vous avez créée les informations ci-dessous :

Nom Prénom Sexe date de naissance

téléphone adresse no postal

ville canton

Ochon Paul H 8.8.1995 324661155 Place des Peupliers 3

2900 Porrentruy JU

Ochon Eric H 8.8.1995 324661155 Place des Peupliers 3

2900 Porrentruy JU

Gross Jean H 24.3.1995 324668341 La condemène 78

2950 Courgenay JU

Fonfec Sophie F 14.12.1994 324711230 Rue du Général-Comman 26

2950 Courgenay JU

Camé Léon H 2.1.1995 273956619 Rue de la Scierie 1

1965 Savièse VS

Darc Jeanne F 31.1.1995 273224614 Rue de Condémines 22

1950 Sion VS



Sapin Noëlle F 14.3.1996 219635678 Promenade des Pêcheurs 6

1820 Montreux VD

Tamère Dominique F 18.1.1995 324666391 Vieille Rue 2 2900 Porrentruy JU

Tanlère Edmond H 31.12.1994 324669912 Route de Varandin 9

2905 Courtedoux JU

Nord Paul H 21.1.1996 324661762 Route de Montancy 332

2903 Villars-sur-Fontenais

JU

RecherchesAvec des commandes SQL, recherchez dans votre base de données de copains :1. tous les Paul ;2. le numéro de téléphone de Sophie Fonfec ;3. tous ceux nés avant 1995 ;4. tous ceux qui sont nés en janvier 1995 ;5. tous ceux qui habitent Porrentruy ;6. le nombre de non-jurassiens ;7. toutes les valaisannes.

Indication : pour les dates, consultez la page http://dev.mysql.com/doc/refman/5.0/fr/date-and-time-functions.html

Exercice 9.9 : Développer une base de données de A à ZExercice 9.9 : Développer une base de données de A à Z

Le cahier des chargesUne école veut développer une base de données pour sa bibliothèque. Voici les détails à prendre

en compte pour la création de la base de données qui permettra la gestion de la bibliothèque :

• Grâce au système informatique, un abonné devra pouvoir retrouver un livre dans les rayons en connaissant son titre. L'abonné devra aussi pouvoir connaître la liste des livres d'un auteur ou la liste par éditeur.

• Les livres sont identifiés par un code catalogue affecté à l'achat et par un code rayon qui permet de les situer dans la bibliothèque. Chaque livre est acheté en un ou plusieurs exemplaires (on stocke la date d'acquisition). Tous les exemplaires d'un même livre ont un code rayon différent mais le même code catalogue. Les différents exemplaires d'un même livre peuvent éventuellement provenir de différents éditeurs.

• La bibliothèque gère un fichier des abonnés organisé par numéro de matricule qui contient les coordonnées (nom, adresse et téléphone) de l'abonné.

• La gestion des prêts implique la possibilité de connaître à tout moment la liste des livres détenus par un abonné, et inversement, qu'on puisse retrouver le nom des abonnés détenant un livre non présent dans les rayons.

• Les prêts sont accordés pour une durée de quinze jours, éventuellement renouvelable, si aucune demande de ce livre n'a eu lieu entre-temps. Il faudrait donc connaître pour chaque livre emprunté, la date du prêt et la date de retour.

Les fonctions que le système devra effectuer sont :

• la gestion des prêts (prêts, réservations et retours) ; • la mise à jour du fichier des livres (mises au rebut ou achats de livres) ; • la mise à jour du fichier des abonnés (retraits et nouvelles inscriptions) ; • la possibilité d'aide au choix d'un ouvrage grâce à une procédure de recherche par nom

d'auteur ou par éditeur.


http://dev.mysql.com/doc/refman/5.0/fr/date-and-time-functions.html

http://dev.mysql.com/doc/refman/5.0/fr/date-and-time-functions.html

Bases de données

À faire :1. Construire le schéma entité-association modélisant cette situation en indiquant les entités,

les attributs et les relations. 2. Traduire ce schéma conceptuel en un modèle relationnel. 3. Construire cette base de données avec EasyPHP. 4. Introduire quelques livres et abonnés dans cette base afin de pouvoir effectuer des tests. 5. Traduire les questions suivantes en requêtes SQL et les tester :

• Qui a emprunté « Madame Bovary » ?• Quels sont les livres de Gustave Flaubert que la bibliothèque possède ?• Quand « Les 9 couronnes » a-t-il été emprunté (il n'y a qu'un exemplaire) ?• Quels sont tous les livres de l'éditeur « Gallimard » ?• Quel est le courriel de la personne qui a réservé « Mangeclous » (il n'y a qu'un

exemplaire) ?• Quels sont les livres qui devront être restitués demain ?

6. Rendre un rapport de 3 pages : • Page 1 : Modèle conceptuel (point 1)• Page 2 : Tables de la base de données• Page 3 : Requêtes SQL du point 5.

http://ow.ly/4vzKn

9.7. Exemples de bases de donnéesSeshat

Seshat est une base de données de mathématiciens. Comme vous pourrez le constater, cette base de données permet de retrouver rapidement un mathématicien selon divers critères : nom, année de naissance, année de mort, jour de naissance, ville de naissance ou de mort, signe astrologique, pays, etc. Elle permet aussi de trouver tous les contemporains d'un mathématicien. La mise en page peut aussi se changer aisément et est la même pour tous les mathématiciens.

En fait, les pages que vous verrez n'existent pas ; elles sont construites à chaque requête d'après les informations figurant dans la base de données. De même, la chronologie des mathématiciens est construite en visitant toute la base de données. Cela signifie que si l'on ajoute ou enlève un mathématicien à la base de données, le tableau chronologique sera automatiquement modifié lors de la prochaine requête.

Les blogsLes blogs sont aussi basés sur une base de données. Les contenus des billets sont stockés dans un

champ, ainsi que des informations comme le sujet, le nombre de lectures, la date, ... Quand on ouvre le blog, le système affiche les n derniers billets, par ordre antéchronologique.

Les quiz interactifsPour les quiz aussi, les questions sont stockées dans une base de données, avec les réponses, la

difficulté, le chapitre concerné, etc. Les questions sont ensuite choisies par le système au hasard ou selon certains critères.

Sources[1] « Conception des bases de données relationnelles »,

<http://tecfa.unige.ch/staf/staf-h/tassini/staf2x/Heidi/last_bd.htm>

[2] Hugo Etiévant, « Cours complet de Mysql », <http://cyberzoide.developpez.com/php4/mysql/>


http://cyberzoide.developpez.com/php4/mysql/

http://tecfa.unige.ch/staf/staf-h/tassini/staf2x/Heidi/last_bd.htm

http://ow.ly/4vzKn


http://ow.ly/2yInE

Chapitre 10Sécurité informatique

Fred Cohen

Leonard Adleman

Crédit photo - LIFE - Time Inc

26 sept. 1988

10.1. Logiciels malveillantsDepuis que Fred Cohen, considéré comme l'un des pères de la virologie, a créé l'un des premiers

virus en 1983, des dizaines de milliers de virus ont vu le jour et les éditeurs d'antivirus en repèrent chaque jour de nouveaux.

On attribue le terme « virus informatique » à Leonard Adleman, chercheur en informatique théorique et professeur en informatique et en biologie moléculaire, co-inventeur du cryptosystème RSA. C'est Fred Cohen qui a donné une définition formelle.

Aujourd'hui, la grande variété de programmes malicieux incite les spécialistes à parler de « codes malveillants » (ou « malwares » en anglais) plutôt que de virus.

10.1.1.VirusUn virus informatique est un programme écrit dans le but de se propager à d'autres ordinateurs en

s'insérant dans d'autres programmes appelés « hôtes ». Il peut avoir comme effet de nuire en perturbant plus ou moins gravement le fonctionnement de l'ordinateur infecté. Il peut se répandre à travers tout moyen d'échange de données numériques comme Internet, mais aussi les disquettes, les cédéroms, les clefs USB, etc.

Son appellation provient d'une analogie avec le virus biologique puisqu'il présente des similitudes dans sa manière de se propager en utilisant les facultés de reproduction de la cellule hôte.

Les virus informatiques ne doivent pas être confondus avec les vers, qui sont des programmes capables de se propager et de se dupliquer par leurs propres moyens, mais sans contaminer de programme hôte.

OrigineEn août 1961, trois amis informaticiens, Doug McIlroy, Victor Vyssotsky et Robert Morris

Senior, ingénieurs des laboratoires Bell Telephone, créent un jeu de survie et d'évolution baptisé DARWIN. Un nouveau jeu, fortement inspiré de DARWIN, apparaît en 1984 : CORE WAR, que le grand public découvrira réellement au travers de la publication de A. K. Dewdney dans la revue Scientific American : « In the game called Core War hostile programs engage in a battle of bits ».

Pour ce jeu, chaque joueur écrit un programme, ensuite chargé en mémoire vive. Le système d'exploitation exécute tour à tour une instruction de chacun des logiciels. L'objectif du jeu est de détruire les programmes adverses tout en assurant sa propre prolifération. Les joueurs ne connaissent évidemment pas l'emplacement du programme adverse. Les logiciels sont capables de se recopier, de se réparer, de se déplacer eux-mêmes en différentes zones de la mémoire et « d'attaquer » le logiciel adverse en écrivant aléatoirement dans d'autres zones de la mémoire. C'est exactement un des principes de programmation des virus. La partie se termine au bout d'un temps défini ou lorsque l'un des joueurs voit tous ses programmes inactifs ou détruits. Le vainqueur est celui qui possède le plus grand nombre de copies actives.

Didier Müller 10-1 Avril 2011

http://ow.ly/2yInE

Sécurité informatique

Différents types de virusLe virus classique est un programme, souvent écrit en assembleur, qui s'intègre dans un

programme hôte, le plus souvent à la fin du code, mais aussi au début, ou au milieu. Chaque fois que l'utilisateur exécute ce programme infecté, il active le virus qui va s'intégrer dans d'autres programmes. De plus, lorsqu'il contient une charge utile1, il peut, après un certain temps (qui peut être très long) ou un événement particulier, exécuter une action prédéterminée. Cette action peut aller d'un simple message apparaissant à l'écran à la détérioration de certains fichiers voire même à la destruction complète de toutes les données de l'ordinateur.

Les virus-vers, apparus en 2003 sont des virus classiques car ils ont un programme hôte, mais s'apparentent aux vers, car :

• leur mode de propagation est lié au réseau, comme des vers, en général via l'exploitation de failles de sécurité ;

• comme des vers, leur action se veut discrète et non-destructrice pour les utilisateurs de la machine infectée ;

• comme des vers, ils poursuivent des buts à visée large, tels que l'attaque par saturation des ressources d'un serveur par des milliers de machines infectées se connectant simultanément.

10.1.2.VerUn ver informatique (« worm » en anglais) est un logiciel malveillant qui se reproduit sur

plusieurs ordinateurs en utilisant un réseau informatique comme Internet. Le terme « ver informatique » fit son apparition pour la première fois en 1975 dans un livre de science-fiction de John Brunner intitulé The Shockwave Rider2.

Un ver, contrairement à un virus informatique, n'a pas besoin d'un programme hôte pour se reproduire. Il exploite les différentes ressources de l'ordinateur qui l'héberge pour assurer sa reproduction.

L'objectif d'un ver n'est pas seulement de se reproduire. Le ver a aussi habituellement un objectif malicieux, par exemple :

• espionner l'ordinateur où il se trouve ; • offrir une porte dérobée3 à des pirates informatiques ; • détruire des données sur l'ordinateur où il se trouve ou y faire d'autres dégâts ; • envoyer de multiples requêtes vers un serveur Internet dans le but de le saturer (déni de

service4). L'activité d'un ver a souvent des effets secondaires comme :

• le ralentissement de la machine infectée ; • le ralentissement du réseau utilisé par la machine infectée ; • le plantage de services ou du système d'exploitation de la machine infectée.

Des vers écrits sous forme de script peuvent être intégrés dans un courriel ou sur une page HTML. Ces vers sont activés par les actions de l'utilisateur qui croit accéder à des informations lui étant destinées. Un ver peut aussi être programmé en C, C++, assembleur, ou dans un autre langage de programmation. La plupart du temps, les vers utilisent des failles de logiciels pour se propager. Ces failles sont habituellement corrigées par les éditeurs de logiciels dès que les vers apparaissent.

OrigineCREEPER est considéré comme le premier ver informatique. Développé, en 1971, pour les

ordinateurs fonctionnant avec le système d'exploitation Tenex par Bob Thomas de la société Bolt Beranek and Newman (BBN), il rentre dans la catégorie des vers créés par des chercheurs soucieux d'améliorer notre quotidien.

CREEPER est un programme de démonstration développé en réponse aux besoins des contrôleurs aériens. Ces derniers, à partir de l'ARPANET, souhaitaient recevoir une notification lorsque les

1 En informatique, on utilise ce terme au figuré pour désigner la partie du code exécutable d'un virus qui est spécifiquement destinée à nuire (par opposition au code utilisé par le virus pour se répliquer notamment).

2 Le livre a été traduit en français avec le titre « Sur l'onde de choc ».3 Dans un logiciel, une porte dérobée (de l'anglais backdoor, littéralement porte de derrière) est une fonctionnalité inconnue de l'utilisateur

légitime, qui donne un accès secret au logiciel.4 Voir paragraphe 10.2.5



avions sous leur contrôle passaient de la surveillance d'un ordinateur à l'autre. Le ver se propage de machine en machine et s'efface des machines qu'il visite, au fur et à mesure de sa progression. À chaque exécution, le message I'm creeper! Catch me if you can! s'affiche sur les consoles. D'autres versions du ver ont vu le jour par la suite. Dans ces versions, CREEPER se reproduisait de machine en machine sans s'effacer à chaque passage. Face à ce dysfonctionnement, Bob Thomas développe un autre ver REAPER qui efface et élimine CREEPER et s'auto-détruit ensuite. Le premier ver antiviral est né.

Durant ses études à l'Université de Cornell, Robert Tappan Morris conçoit un programme dans le but de mesurer la taille du réseau Internet. Le programme a pour objectif de s'introduire sur les systèmes Unix reliés au réseau Internet et de se répliquer pour propager son activité. C'est le 2 novembre 1988 que le premier ver Internet a été lancé à partir du MIT. Le « VER MORRIS » n'a pas été écrit pour causer des dommages. Cependant, le mécanisme de reproduction forcée mis en place va favoriser l'infection sur le réseau Internet, mais va également engendrer une saturation des ressources de chaque système. En quelques jours, ce sont plus de 6000 serveurs Unix qui vont être infectés sur un parc d'environ 60'000 serveurs reliés au réseau Internet de l'époque, soit un taux d'infection de 10%. S'apercevant des dégâts qu'il était en train de causer, Robert T. Morris alerta certains membres de la communauté informatique et une parade fut finalement trouvée. Morris fut condamné à une peine de travaux d'intérêt général et à une amende de 10'000 dollars. La communauté Internet - alors réduite - pris conscience de la menace de ce type de code malveillant et c'est ainsi que fut créé le CERT (Computer Emergency Response Team).

I LOVE YOU est le nom d'un ver informatique, apparu pour la première fois le 4 mai 2000 et envoyé sous forme d'une pièce jointe à un courriel intitulé I LOVE YOU. Le destinataire naïf du courriel croit que la pièce jointe est un fichier de texte. En fait, en ouvrant le fichier, l'utilisateur déclenche l'exécution d'un programme contenu dans le fichier. Ce programme explore la liste des contacts de l'utilisateur et envoie à tous ces contacts un courriel contenant la même pièce jointe infectée, assurant ainsi sa reproduction. Il s'est répandu en quatre jours sur plus de 3,1 millions de machines dans le monde et causé de gros dégâts : I LOVE YOU s'en prend à de multiples extensions de fichiers, qui sont alors perdus.

Les vers actuels se propagent principalement comme le faisait le ver I LOVE YOU

10.1.3.Cheval de TroieUn cheval de Troie est un logiciel d'apparence légitime, mais conçu pour exécuter des actions à

l'insu de l'utilisateur. En général, un cheval de Troie tente d'utiliser les droits appartenant à son environnement pour détourner, diffuser ou détruire des informations, ou encore pour ouvrir une porte dérobée qui permettra à un attaquant de prendre à distance le contrôle d'un ordinateur, via Internet.

Le téléchargement de programmes gratuits et le partage des programmes sont les principales sources de diffusion des chevaux de Troie. Ils sont également très fréquents dans certains types de courriels.

Un cheval de Troie n'est pas un virus informatique car il ne se reproduit pas par lui-même. Un cheval de Troie est conçu pour être reproduit lors de téléchargements ou de copies par des utilisateurs naïfs, attirés par les fonctionnalités du programme.

10.1.4.Bombe logiqueOn appelle « bombes logiques » les dispositifs programmés dont le déclenchement s'effectue à un

moment déterminé en exploitant la date du système, le lancement d'une commande, ou n'importe quel appel au système. Ainsi, ce type de virus est capable de s'activer simultanément sur un grand nombre de machines. Par exemple : la bombe logique TCHERNOBYL s'est activée le 26 avril 1999, jour du 13ème anniversaire de la catastrophe nucléaire...

Généralement, le but des bombes logiques est de créer un déni de service !

10.1.5.Logiciel espionUn logiciel espion (en anglais « spyware ») est un logiciel malveillant qui s'installe dans un

ordinateur dans le but de collecter et transférer des informations sur l'environnement dans lequel il



s'est installé, très souvent sans que l'utilisateur n'en ait connaissance. L'essor de ce type de logiciel est associé à celui d'Internet qui lui sert de moyen de transmission de données.

Un logiciel espion est composé de trois mécanismes distincts :• l'infection, qui installe le logiciel. Ce mécanisme est identique à celui utilisé par les

virus, les vers ou les chevaux de Troie ;• la collecte d'information ;• la transmission à un tiers, généralement assurée via le réseau Internet. Le tiers peut être

le concepteur du programme ou une entreprise. Le logiciel espion peut afficher des offres publicitaires, télécharger un virus, installer un cheval

de Troie, capturer des mots de passe en enregistrant les touches pressées au clavier ou encore espionner les sites Internet visités.

10.1.6.Machine zombieEn sécurité informatique, une machine zombie est un ordinateur contrôlé à l'insu de son

utilisateur par un pirate informatique. Ce dernier l'utilise alors le plus souvent à des fins malveillantes, par exemple afin d'attaquer d'autres machines en dissimulant sa véritable identité.Un zombie est souvent infesté à l'origine par un ver ou un cheval de Troie.

Réseau de machines zombies (Botnet)Un réseau de machines zombies peut être constitué et contrôlé par une ou plusieurs personnes,

afin d'obtenir une capacité considérable et d'avoir un impact plus important.Des armées de zombies sont utilisées dans les attaques de type déni de service ou des tâches

diverses comme les envois en masse de courriers non sollicités (spam). Un réseau de machines zombies peut aussi être utilisé afin de fournir aux pirates une puissance

de calcul phénoménale, leur permettant de déchiffrer un code en un temps considérablement plus court que sur une machine.

En dehors de l'aspect économique, les attaques informatiques peuvent devenir une arme de propagande ou de rétorsion, notamment lors de conflits armés ou lors d'événements symboliques. Par exemple, lors du conflit entre la Russie et la Géorgie en 2008, le réseau géorgien a été attaqué sous de multiples formes pour le rendre indisponible. En 2007, une attaque d'importance contre l'Estonie a également eu lieu : la motivation des pirates aurait été le déplacement d'un monument en hommage aux soldats russes du centre de la capitale estonienne.

Coup de filet en Espagne pour démanteler Mariposa, un botnet géant

La police espagnole a arrêté trois hommes soupçonnés d'être les animateurs de Mariposa (papillon en espagnol), l'un des plus grands réseaux d'ordinateurs zombies jamais mis au jour. L'infection se propageait via MSN ou les réseaux pair-à-pair. Ces dernières semaines, les autorités espagnoles ont arrêté trois hommes soupçonnés d'être les animateurs du réseau d'ordinateurs zombies (botnet) Mariposa (papillon en espagnol), un botnet spécialisé notamment dans le vol d'informations à grande échelle. Les experts en sécurité estiment qu'il s'agit d'un des botnets les plus importants au monde et qu'il est probable que Mariposa était devenu plus imposant que le botnet constitué via l'infection Conficker5. D'après les dernières estimations, près de 12,7 millions d'adresses IP ont été recensées comme ayant un jour été utilisées par les nœuds contrôlés par le botnet et ce dans 190 pays. En septembre 2009, Defence Intelligence, une société spécialisée dans la sécurité informatique basée à Ottawa estimait à plus de 7000 le nombre de nouveaux systèmes infectés chaque jour par Mariposa.Selon la police espagnole, les trois suspects, âgés de 25, 30 et 31 ans, n'avaient pas d'antécédents judiciaires. D'autres arrestations sont attendues dans d'autres pays.

Reynald Fléchaux sur www.lemagit.fr – 3 mars 2010

5 Conficker (connu aussi sous les noms de Downup, Downandup et Kido) est un ver informatique qui est apparu fin novembre 2008



10.1.7.Protection contre les codes malveillants

L'antivirus : le surveillant principalLe rôle de l'antivirus est de débusquer tous les virus qui essaient de s'installer dans l'ordinateur.

Mais en réalité, il n'est capable de repérer que les codes malveillants qu'il connaît déjà.Trois méthodes principales sont utilisées pour détecter des virus et autres codes malveillants :• L'analyse de signatures : elle consiste à vérifier la signature du programme ou du fichier

en question. Cette signature est une partie de code générée à partir du contenu du fichier qui permet de vérifier qu'il n'a pas été modifié ultérieurement. Elle constitue en quelque sorte sa carte d'identité. Mais cette simple analyse de signatures est limitée et ne semble plus suffisante aujourd'hui. En effet, elle ne s'applique qu'aux virus connus et analysés. De plus, la gestion d'une base virale est contraignante : stockage sécurisé des données, espace de stockage, multiples mises à jour, etc.

• L'analyse heuristique : elle recherche des actions potentiellement dangereuses. Mais cette technique, peu fiable, est source de fausses alertes.

• L'analyse comportementale : il s'agit d'étudier le comportement des logiciels installés sur le PC. Analysant en permanence l'activité de l'ordinateur, l'antivirus surveille et tente de bloquer des actions qui ne sont pas répertoriées dans sa base comportementale : tentatives d'ouverture en lecture/écriture de fichiers exécutables, écriture sur une partition, etc.

Lors d'un concours organisé fin octobre 2009 par Éric Filiol à l'ESIEA (École Supérieure d'Informatique, Électronique, Automatique) de Laval, deux experts ont réussi très rapidement à désactiver des antivirus. Seul Dr. Web a résisté dans le temps d'une heure imparti par les organisateurs. Certains antivirus très connus n'ont quant à eux pas tenu plus de quelques minutes ! Les résultats de ce concours montrent dans une certaine mesure qu'un virus bien conçu peut lancer une charge de désactivation visant les produits antivirus majeurs du marché. Le poste de l'utilisateur devient alors vulnérable, sans que ce dernier en soit conscient.

Le pare-feuUn pare-feu (« firewall » en anglais) est un logiciel ou un matériel, qui a pour but de faire

respecter la politique de sécurité du réseau, celle-ci définissant quels sont les types de communication autorisés ou interdits. Ce système filtre en permanence toutes les connexions entrantes et sortantes d'un ordinateur, servant d'intermédiaire entre le réseau local (ou la machine locale) et un ou plusieurs réseaux externes. En surveillant les connexions, il permet de protéger un ordinateur ou un réseau d'ordinateurs des intrusions provenant d'un réseau tiers (notamment Internet).

10.2. Attaques et fraudes

10.2.1.SpamLe pourriel (québécisme) ou spam (anglicisme) désigne une

communication électronique non sollicitée, en premier lieu via le courrier électronique. Il s'agit en général d'envois en masse effectués à des fins publicitaires, malhonnêtes ou sans but premier sinon que d'agacer leur destinataire.

Une analyse des données de plus d'un milliard de courriels interceptée par les Barracuda Spam Firewalls dans le monde entier, estime que le niveau de spam a atteint en 2010 95% du total des courriels.

HistoireLe premier pourriel a été envoyé le 3 mai 1978 par Gary Thuerk, marketeur travaillant chez



DEC. Il envoya son message à près de la totalité des utilisateurs d'ARPAnet (ancêtre d'Internet) vivant sur la côte ouest des États-Unis, soit environ 600 personnes. Il fit cela sans mauvaise intention, afin d'inviter ces utilisateurs technophiles à une démonstration de la gamme DEC. Voulant éviter d'écrire un message à chaque adresse, il mit les 600 adresses directement dans le champ « Destinataire ». Les réactions furent vives et contrastées, l'administration américaine gérant le réseau condamnant d'office la pratique, la jugeant non-conforme aux termes d'utilisation du réseau.

L'association de spam et de indésirable provient d'un sketch comique des Monty Python dans lequel le même mot, désignant un jambon en boîte de basse qualité, envahit la conversation et le menu d'un petit restaurant. SPAM est la contraction de Spiced Pork And Meat (jambon et viande épicés) et est une marque créée et déposée par Hormel Foods en 1937.

Dans les blogsLa présence de liens vers un site web est un critère important de classement dans les moteurs de

recherche. Afin d'augmenter artificiellement le nombre de liens pointant vers leurs sites, certains créent des blogs, ou mettent des messages de commentaires dans des blogs préexistants, uniquement pour ajouter des liens vers un ou plusieurs sites web à promouvoir.

L'automatisation de ce genre de pollution a mené plusieurs logiciels de blog à introduire des contrôles (Captcha) qui rendent cette automatisation par une machine plus complexe à réaliser.

L'anti-spamFiltrant les courriels, l'anti-spam s'appuie sur différentes banques de données, notamment des

listes noires constituées d'adresses internet ou de pays connus pour être à l'origine de nombreux spams. Une seconde famille d'anti-spams utilise l'authentification des expéditeurs. Ce filtrage peut éviter de recevoir les messages qui véhiculent les virus.

10.2.2.

Un captcha est une forme de test de Turing permettant de différencier de manière automatisée un utilisateur humain d'un ordinateur.

Les captcha sont entièrement automatisés. L'algorithme utilisé pour créer un captcha est souvent public, bien qu'il puisse être breveté. Ceci est fait dans le but de démontrer que casser ce type de test nécessite la résolution d'un problème difficile en faisant appel à des notions de l'intelligence artificielle, plutôt que la découverte des secrets de l'algorithme, qui pourraient être obtenus par décompilation ou un autre moyen.

Les captchas sont utilisés :• contre le spam :

• lors de l'inscription à des webmails gratuits (dont les comptes pourraient être utilisés par la suite pour l'envoi de courriers non sollicités),

• lors de la soumission de messages dans des forums de discussion et des blogs, qui pourraient permettre de faire du référencement abusif (spamdexing) ;

• contre l'extraction automatisée de bases de données ; • contre les tentatives d'attaque par force brute ; • pour la participation à des sondages (dont les résultats pourraient être faussés par des votes

automatisés).

Types de captchaUn captcha est utilisé sur Internet dans les formulaires pour se prémunir contre les soumissions

automatisées et intensives réalisées par des robots malveillants. La vérification utilise généralement la capacité d'analyse d'image de l'être humain. Un captcha usuel requiert que l'utilisateur tape les lettres et les chiffres visibles sur une image distordue qui apparaît à l'écran.



Certains sites Web préfèrent afficher une image qui contient une question simple (par exemple « 3+4=? » ou « Quel est le quatrième mot de cette phrase ? ».

La reconnaissance d'images est un domaine où les ordinateurs sont encore très mauvais, d'où l'idée de les utiliser pour un captcha. Le système proposé par www.hotcaptcha.com6 en 2006 affichait des photos en provenance du site www.hotornot.com, où les utilisateurs évaluent la beauté des personnes, femmes ou hommes.. Il fallait choisir les 3 photos les plus belles (celles qui ont le meilleur score moyen) parmi 9 pour être identifié comme un être humain. Comme la notion de beauté est complètement étrangère aux machines, elles ne peuvent pas reconnaître une belle femme (ou un bel homme).

Le problème est qu'il est parfois difficile de trouver les trois personnes les plus belles, parce que les goûts et les couleurs restent très subjectifs...

OrigineLa première réflexion sur la création de tests automatiques qui pourraient distinguer les humains

des ordinateurs dans le but de contrôler l'accès aux services web est apparue dans un manuscrit de 1996 intitulé Verification of a human in the loop, or Identification via the Turing Test. Des captcha primitifs semblent avoir été développés plus tard, en 1997 chez AltaVista par Andrei Broder et ses collègues dans le but d'empêcher des robots d'ajouter des sites à leur moteur de recherche.

6 Ce site n'existe plus aujourd'hui


http://www.hotornot.com/

http://www.hotcaptcha.com/


En 2000, von Ahn et Blum développèrent et publièrent la notion de captcha, qui comprenait tout programme qui pouvait différencier un humain d'un ordinateur. Ils inventèrent de multiples exemples de captcha, dont les premiers qui furent largement utilisés (par Yahoo! notamment).

ContournementIl y a plusieurs approches pour mettre en échec un captcha :• utiliser une main-d'œuvre humaine pour les reconnaître ; • exploiter les bugs dans les implémentations qui permettent à l'attaquant de passer

complètement outre le captcha ; • améliorer les logiciels de reconnaissance de caractères.

10.2.3.HoaxEn informatique, les canulars (appelés « hoax » en anglais) se trouvent souvent sous la forme de

courriel ou de simple lettre-chaîne. Dans ce dernier cas, Internet ne fait qu'amplifier un phénomène qui existait déjà à travers le courrier traditionnel. Le mot hoax est une simplification du premier mot de l'expression « hocus pocus », signifiant « tromperie » ou « escroquerie ».

À la différence des pourriels qui sont la plupart du temps envoyés de manière automatisée à une liste de destinataires, les canulars sont, eux, relayés manuellement par des personnes de bonne foi à qui on demande de renvoyer le message à toutes ses connaissances.

Quelques hoax connus• Bonsai Kitten : un courriel révolté raconte le calvaire de chats, élevés en bocaux pour en

brider la croissance à la manière des bonsaïs. • Cuire un œuf avec un portable : deux scientifiques russes auraient réussi à faire cuire un

œuf placé entre deux téléphones cellulaires grâce à l'énergie émise par ceux-ci. • Noëlie : un hoax circule depuis plusieurs années à la recherche d'un donneur de moelle du

groupe sanguin AB pour sauver une petite fille appelée Noëlie. Si le mail était une véritable recherche au départ, la petite fille n'a pu être sauvée et la chaîne continue de tourner malgré l'appel des parents et du CHU d'Angers qui continuent à être régulièrement appelés.

• La nuit des deux lunes. Depuis 2003, chaque 27 août, la nouvelle circule que la planète Mars s'approchera si près de la Terre qu'elle nous apparaîtra aussi grosse que la pleine lune. Il est vrai que, depuis 60'000 ans, jamais Mars n'avait été si proche de la Terre que le 27 août 2003. Cependant, son diamètre apparent était 70 fois plus petit que le disque de la pleine lune...

Comment reconnaître un hoax ?Il existe plusieurs sites spécialisés qui recensent les canulars informatiques. Les deux plus connus

en français sont www.hoaxbuster.com et www.hoaxkiller.fr.

10.2.4.Hameçonnage (phishing)L'hameçonnage, appelé en anglais « phishing », est une technique utilisée par des fraudeurs pour

obtenir des renseignements personnels dans d'usurper une identité. La technique consiste à faire croire à la victime qu'elle s'adresse à un tiers de confiance — banque, administration, etc. — afin de lui soutirer des renseignements personnels : mot de passe, numéro de carte de crédit, date de naissance, etc. L'hameçonnage peut se faire par courrier électronique, par des sites web falsifiés ou autres moyens électroniques.

Les criminels informatiques utilisent généralement l'hameçonnage pour voler de l'argent. Les cibles les plus populaires sont les services bancaires en ligne, et les sites de ventes aux enchères tels que eBay ou Paypal. Les adeptes de l'hameçonnage envoient habituellement des courriels à un grand nombre de victimes potentielles.

Une approche souvent utilisée est de se faire passer pour une banque et d'indiquer à la victime que son compte a été désactivé à cause d'un problème et que la réactivation ne sera possible qu'en cas d'action de sa part. Le message fournit alors un lien qui dirige l'utilisateur vers une page web qui


http://www.hoaxkiller.fr/

http://www.hoaxbuster.com/


ressemble à s'y méprendre au vrai site de la société. Arrivé sur cette page trompeuse, l'utilisateur est invité à saisir des informations confidentielles qui sont alors enregistrées par le criminel.

Il faut savoir que jamais une banque ne demandera à un client de lui fournir un code confidentiel.

10.2.5.Attaque par déni de serviceUne attaque par déni de service (en anglais, Denial of Service attack ou DoS attack) est une

attaque sur un serveur informatique qui a pour conséquence l'incapacité pour le serveur de répondre aux requêtes de ses clients.

Pour illustrer ce dont il s'agit, il suffit d'imaginer ce qui arriverait si des centaines de personnes téléphonaient sans arrêt au même restaurant pour commander des choses qu'elles ne veulent pas vraiment. Les lignes téléphoniques seraient alors saturées, et la cuisine serait si débordée qu'elle ne pourrait prendre d'autres commandes.

Une attaque par déni de service distribuée (en anglais, Distributed Denial of Service attack ou DDoS attack) est une attaque par déni de service dans laquelle le serveur cible est attaqué par plusieurs ordinateurs simultanément. Dans ce type d'attaque, les pirates se dissimulent souvent derrière des machines zombies, utilisées à l'insu de leurs propriétaires.

Depuis quelques années, l'attaque par déni de service distribuée est aussi utilisée à des fins de chantage auprès d'entreprises dont l'activité commerciale repose sur la disponibilité de leur site Web. Ces fraudes sont habituellement le fait d'organisations criminelles mafieuses et non de pirates isolés.

Le 6 août 2009, Twitter, Facebook et certains sites appartenant à Google ont été victimes d'une cyberattaque. Les millions d'utilisateurs se sont vus dans l'impossibilité de se connecter pendant plusieurs heures.

Pour quelles raisons un pirate en voudrait-il à Twitter au point de rendre son site indisponible ? Au rang des motivations des dénis de service, on compte :- le chantage : c'est la principale motivation pour les attaques. D'ordinaire, ce type d'attaque vise plutôt des sites de e-commerce, ou de jeu d'argent en ligne : c'est-à-dire, des sociétés dont l'existence même repose entièrement sur leur visibilité sur Internet. L'attaque commence par quelques minutes d'indisponibilité ; puis le site revient en ligne, et l'entreprise reçoit un e-mail du pirate, demandant le versement d'une somme d'argent en échange de l'arrêt des hostilités. Pour ces sociétés, la perte du chiffre d'affaires d'une seule journée est une catastrophe. Et même si ces sociétés n'aiment pas en faire la publicité, dans de nombreux cas, les escrocs reçoivent bien la rançon demandée (c'est d'ailleurs à la remise de la rançon que sont réalisées la plupart des arrestations). Ici, la société Twitter répond bien à ce critère de dépendance extrême vis-à-vis d'Internet ; plus de twitter.com = plus de société. Cependant, le chiffre d'affaires réalisé par la société sur Internet est théoriquement nul, et elle se remettra donc très bien de quelques heures d'indisponibilité, malgré avoir perdu quelques plumes dans les médias. Cela cadre donc mal avec une tentative de racket ;- la censure : il est possible que des messages aient été relayés sur Twitter, et que ces messages n'aient pas plu à quelqu'un, qui aurait décidé en conséquence d'attaquer le site. Ce type d'attaques est monnaie courante, de nombreux chercheurs en sécurité en faisant régulièrement les frais : le site www.abuse.ch est régulièrement pris pour cible en raison du contenu qui y est publié ; la société SpamHaus est régulièrement attaquée également ; et la fondation CastleCops (qui n'existe plus) était en son temps parmi les priorités de nombreux pirates, qui ont poussé le vice jusqu'à provoquer un déni de service avec des donations issues de comptes bancaires volés, l'objectif étant de compromettre la fondation aux yeux de sa propre banque. Dans le cas de Twitter, il ne serait pas étonnant que parmi les millions de tweets postés chaque jour, certaines aient déplu à des pirates, le site étant devenu un relai fulgurant des rumeurs et de la contestation politique (souvenons-nous de l'appel au déni de service contre des cibles iraniennes relayé sur la plateforme) ;- la démonstration de force : les pirates cherchent souvent à démontrer leurs capacités de nuisance sur des cibles réelles, de manière à séduire des "clients" potentiels qui pourraient faire appel à leurs services. En matière de déni de service, ce type de démonstration de force est quasi systématique : pour vérifier la puissance du botnet, le pirate choisit une cible neutre, sans rapport avec l'usage réel qu'il fera du botnet ultérieurement. Son futur client peut ainsi être rassuré sur la qualité de l'infrastructure qu'il va louer. C'est notamment ce qu'il semble s'être passé début 2007, avec l'attaque massive contre les serveurs DNS racines. Cette hypothèse est plausible, Twitter étant une cible particulièrement médiatique, la publicité du pirate est assurée ; cependant, Twitter semble avoir quelques soucis chroniques de bande passante, lors de pics d'activité le site est parfois indisponible en raison de sa propre popularité (par exemple à la mort de Michael Jackson). Twitter n'est donc pas une cible hors de portée pour un pirate doté d'un outillage "moyen".



Puis, on notera comme motivations plus improbables : l'attaque pour le plaisir, ou encore l'attaque politique par une puissance étrangère.On ne saura sans doute jamais le fin mot de l'histoire, mais ce type d'attaques est monnaie courante, de nombreuses sociétés en faisant les frais jour après jour. Se prémunir contre ce type d'attaque est très complexe : chaque fois qu'une solution de filtrage est mise en place, les pirates modifient leur attaque : en mobilisant d'autres machines de leur botnet pour multiplier les IP sources, en modifiant les requêtes ou les paquets de données envoyés, en prenant pour cible la partie applicative du site web plutôt que les couches réseaux, etc. Ces attaques ont donc de beaux jours devant elles.

Pierre Caron – Cert-Lexsi (www.zdnet.fr)

10.3. IntégritéUn des problèmes annexes à la cryptographie est la vérification de l'intégrité d'un message :

comment savoir si le message que l'on reçoit n'a pas été modifié en cours de route ? Ce problème peut aussi se poser avec Internet : comment savoir si la version du logiciel X mis en téléchargement sur le web est bien le logiciel original et non pas une version avec un virus ? Quand la police confisque un disque dur pour une enquête, elle a aussi besoin d'assurer l'intégrité de ce disque pour prouver que son contenu n'a pas été modifié entre la confiscation et l'éventuel procès.

La réponse à ces problèmes est la notion de fonction de hachage à sens unique. Cette fonction (H), qui doit être rapide à calculer, transforme un message M de longueur arbitraire en une empreinte numérique h de taille fixée :

h = H(M), où h est de longueur m.

Cette fonction doit en outre avoir les propriétés suivantes : • étant donné un message M, il est facile de calculer l'empreinte h, • étant donné une empreinte h, il est difficile de calculer le message M, • résistance forte à la collision : il est difficile de trouver deux messages M et M' tels que

H(M)=H(M'). Alice envoie à Bob le message lui-même et son empreinte qu'elle aura calculée. Bob calcule à son

tour l'empreinte du message puis la compare avec celle qu'il a reçue. Si ce sont les mêmes, le message n'a pas été modifié.

On peut voir une analogie avec les empreintes digitales : c'est aussi une manière fiable de vérifier l'identité d'un individu avec une petite quantité d'informations.

10.3.1.Deux exemples de fonction de hachage

MD4 et MD5MD5 est une version améliorée de MD4, tous deux conçus par Ron Rivest. MD signifie

« Message Digest », qui peut être traduit par « empreinte » en français. MD4 et MD5 produisent des empreintes de 128 bits. MD5 est un peu lent que MD4. Des faiblesses ont été trouvées et son utilisation se raréfie.

SHA-1SHA signifie « Secure Hash Algorithm » et on utilise souvent le terme SHA-1 pour désigner la

version. Cette fonction de hachage, elle aussi basée sur MD4, a été publiée conjointement par la NSA7 et le NIST8. Elle renvoie une empreinte de 160 bits. C'est l'un des algorithmes les plus utilisés avec le MD5.

7 National Security Agency est un organisme gouvernemental des États-Unis, responsable de la collecte et de l'analyse de toutes les formes de communications, aussi bien militaires et gouvernementales que commerciales ou même personnelles.

8 National Institute of Standards and Technology. Son but est de promouvoir l'économie en développant des technologies, la métrologie et des standards de concert avec l'industrie.



10.3.2.Attaque des anniversairesCombien faut-il réunir de personnes pour avoir 1 chance sur 2 que deux d'entre elles soient nées

le même jour ? Si l'on pose cette question dans la rue, on aura beaucoup de réponses différentes. La plupart des gens pensent qu'il faudra 183 personnes (la moitié de 365). Il n'en est rien. En fait, il suffit de... 23 personnes !

Calculons la probabilité qu'aucune des personnes présentes ait le même anniversaire : nous avons 365 jours possibles pour le premier, 364 pour le deuxième et ainsi de suite. Ce qui nous donne, pour n personnes, 365·364·363·...·(365−n+1) cas favorables. Il y a bien sûr 365n cas possibles. Donc :

p= 364365

⋅363365

⋅362365

⋅⋅365 – n1365

Or, cette probabilité tombe en dessous de 0.5 quand n=23. Ce « paradoxe » a son importance en cryptographie, lorsqu'on étudie les fonctions de hachage.

Pour que cette fonction soit fiable, il ne faut pas que l'on puisse produire deux textes aux sens très différents mais donnant la même empreinte.

Si l'empreinte est codée sur b bits, il y a 2b empreintes possibles. Si l'on prend k textes différents, la probabilité pour que deux textes aient la même empreinte est donc :

1 –1 – 12b 1 – 2

2b 1 – k –12b

Combien l'attaquant doit-il essayer de textes avant de trouver la même empreinte avec une probabilité d'au moins 0.5 ? Le tableau suivant donne des valeurs pour différentes valeurs de b :

Nombre de bitsde l'empreinte (b)

Nombred'empreintes

Nombre de textes à essayer (k)

8 256 13

16 65536 213

32 4.3·109 54562

64 1.8·1019 9.6·109

128 3.4·1038 1.5·1019

160 1.4·1048 1.0·1024

256 1.1·1077 2.8·1038

On voit sur ce tableau qu'on a environ une chance sur deux de trouver deux textes à l'empreinte identique en en essayant un nombre de l'ordre de la racine carrée du nombre d'empreintes.

On considère en général que, pour obtenir un niveau de sécurité correct, il faut prendre une taille d'empreinte d'au moins 128 bits.

10.4. Piratage informatiqueLa plupart du temps, seule une empreinte du mot de passe est stockée sur l'ordinateur. Celle-ci

résulte d'une fonction de hachage, qui est à sens unique (c'est-à-dire qu'on ne peut pas retrouver le mot de passe à partir de son empreinte).

Une attaque sur un mot de passe peut soit se faire sur son empreinte, soit sur l'authentification elle-même. Dans le premier cas, l'attaquant va appliquer la fonction de hachage sur différents mots et les comparer avec l'empreinte dérobée, jusqu'à trouver une équivalence. Dans le deuxième cas, il va directement essayer les mots dans le programme jusqu'à obtenir une authentification réussie.



Vous trouverez les 500 mots de passe les plus utilisés sur : http://ow.ly/2zLyu

10.4.1.Attaque par force bruteL'attaque par force brute est une méthode utilisée en cryptanalyse pour trouver un mot de passe

ou une clé. Il s'agit de tester, une à une, toutes les combinaisons possibles. Cette méthode de recherche exhaustive ne réussit que dans les cas où le mot de passe cherché est constitué de peu de caractères. Pour contrer cette méthode, il suffit simplement de choisir des mots de passe d'une grande longueur ou des clés suffisamment grandes.

Cette méthode est souvent combinée avec l'attaque par dictionnaire (voir paragraphe 10.4.2) pour obtenir de meilleurs résultats.

Parenthèse mathématiqueSi le mot de passe contient n caractères, indépendants (la présence d'un caractère ne va pas

influencer un autre) et uniformément distribués (aucun caractère n'est privilégié), le nombre maximum d'essais nécessaires se monte alors à :

• 26n si le mot de passe ne contient que des lettres de l'alphabet totalement en minuscules ou en majuscules ;

• 52n si le mot de passe ne contient que des lettres de l'alphabet, avec un mélange de minuscules et de majuscules ;

• 62n si le mot de passe mélange les majuscules et les minuscules ainsi que les chiffres. Il suffit en fait d'élever la taille de « l'alphabet » utilisé à la puissance n. Il s'agit ici d'une borne

supérieure et en moyenne, il faut deux fois moins d'essais pour trouver le mot de passe (si celui-ci est aléatoire). En réalité, bien peu de mots de passe sont totalement aléatoires et le nombre d'essais est bien inférieur aux limites données ci-dessus (grâce à la possibilité d'une attaque par dictionnaire).

Le tableau ci-dessous donne le nombre maximum d'essais nécessaires pour trouver des mots de passe de longueurs variables :

3 caractères 6 caractères 9 caractères

lettres minuscules 17'576 308'915'776 5,4 × 1012

lettres minuscules et chiffres 46'656 2'176'782'336 1,0 × 1014

minuscules, majuscules et chiffres 238'328 5,6 × 1010 1,3 × 1016

Sachant qu'un ordinateur personnel est capable de tester plusieurs centaines de milliers voire quelques millions de mots de passe par seconde, on voit qu'un mot de passe de seulement six caractères ne tiendrait pas très longtemps face à une telle attaque.

ConseilsPour éviter des attaques par force brute, la meilleure solution est :• d'allonger le mot de passe ou la clé si cela est possible ; • utiliser la plus grande gamme de symboles possibles (minuscules, majuscules, ponctuations,

chiffres) ; • pour éviter d'avoir à faire face à une attaque par dictionnaire, faire en sorte que le mot de

passe soit aléatoire ; • et pour une sécurité optimum, empêcher de dépasser un nombre maximal d'essais en un

temps ou pour une personne donnée.

La société Imperva, spécialisée en sécurité de données, a publié un rapport portant sur l'analyse de 32 millions de mots de passe d'internautes dérobés en décembre 2009 sur le site communautaire RockYou.com et dévoilés sur le Web par la suite. Selon cette étude, 50% des mots de passe analysés sont relatifs à des prénoms, des mots du dictionnaire ou des séquences de chiffres. 123456 est le mot de passe le plus commun (il sert à près de 291.000 comptes sur RockYou.com), devant 12345 (79.000), 123456789 (77.000), Password (62.000) et iloveyou (51.600). Environ 30% des mots de passe contiennent six caractères ou moins. Selon Imperva, la simplicité de certains mots de passe expose les internautes à des cyberattaques automatisées.


http://ow.ly/2zLyu


10.4.2.Attaque par dictionnaireL'attaque par dictionnaire est une méthode utilisée en cryptanalyse pour trouver un mot de passe

ou une clé. Elle consiste à tester une série de mots de passe potentiels, les uns à la suite des autres, en espérant que le mot de passe utilisé pour le chiffrement soit contenu dans le dictionnaire. Si tel n'est pas le cas, l'attaque échouera.

Cette méthode repose sur le fait que de nombreuses personnes utilisent des mots de passe courants (par exemple : un prénom, une couleur, le nom d'un animal...).

Contenu du dictionnaire et règlesOutre le contenu habituel d'un dictionnaire qui renferme un ensemble de mots, le dictionnaire

peut être fortement amélioré en combinant les mots ou en appliquant certaines règles. Par exemple, pour chaque mot, on peut essayer de changer la casse de certaines lettres. Une autre astuce consiste à répéter deux fois le mot (par exemple « secretsecret »), dans l'espoir que l'utilisateur fasse appel à cette méthode peu sûre pour renforcer son mot de passe. On peut aussi générer des dictionnaires, par exemple pour des numéros de plaque, des numéros de sécurité sociale, des dates de naissance, etc.

LogicielsLe logiciel John the Ripper9, le plus connu dans ce domaine, est fourni avec une liste de règles

qui permettent d'étendre l'espace de recherche et explorer les failles classiques dans l'élaboration des mots de passe ou des clés par les utilisateurs. Il existe des dictionnaires qui contiennent plusieurs millions de mots et qui ne sont pas fournis avec le logiciel. Citons aussi L0phtcrack10 et Cain & Abel11 qui fournissent des services similaires.

Ce type de logiciels n'est pas forcément utilisé dans un but malicieux. Ces outils peuvent être utiles pour les administrateurs qui veulent sécuriser les mots de passe et alerter les utilisateurs sur les risques encourus.

10.4.3.Tables arc-en-cielUne table arc-en-ciel (appelée en anglais « Rainbow Table ») est une structure de données créée

en 2003 à l'EPFL par Philippe Oechslin pour retrouver un mot de passe à partir de son empreinte. Les tables contiennent une grande quantité de chaînes qui proposent en alternance un mot de passe suivi de son empreinte. Une fonction de réduction, qui varie selon la position dans la table permet de recréer un autre mot de passe à partir de l'empreinte et ainsi de suite.

L'algorithme, déjà efficace avec des mots de passe correctement chiffrés l'est a fortiori avec les mots de passe de LAN Manager12 : ils sont trouvés en l'espace de quelques secondes s'ils sont alphanumériques. Les tables peuvent être utilisées pour d'autres fonctions de hachage comme MD5 ou encore SHA-1, ces dernières sont toutefois nettement plus robustes du point de vue cryptographique que LAN Manager et nécessitent des tables plus grandes.

Création de la tableToute l'astuce des tables arc-en-ciel consiste à calculer à partir d'une empreinte un mot de passe.

Attention, pas LE mot de passe qui correspond à l'empreinte (une telle fonction n'existe pas), mais UN mot de passe. On dit que l'on réduit l'empreinte. La seule chose que l'on demande à cette fonction de réduction est d'être cohérente, c'est-à-dire de toujours retourner le même mot de passe quand on lui donne la même empreinte en paramètre.

Le principe de génération d'une table arc-en-ciel est donc le suivant : on part d'un mot de passe, on calcule son empreinte, puis on calcule un nouveau mot de passe à partir de l'empreinte, on calcule l'empreinte de ce mot de passe, et on répète l'opération un certain nombre de fois. Ensuite on stocke dans la table uniquement le mot de passe initial et l'empreinte finale.

9 http://www.openwall.com/john/10 http://www.l0phtcrack.com/11 http://www.oxid.it/12 LAN Manager (gestionnaire de réseau local) est un service serveur pour système d'exploitation développé par Microsoft en collaboration avec

3Com



Puis on recommence le processus. On choisit un nouveau mot de passe, et on construit une nouvelle chaîne.

Nous venons de générer une mini table arc-en-ciel contenant deux lignes où chaque ligne représente une chaîne de quatre mots de passe.

Utilisation de la table pour cracker des empreintesCommençons par le plus facile : essayons de cracker l'empreinte « 269c241b ». Cette empreinte

figure directement dans la table, à la seconde ligne, et est associée avec le mot de passe « qwer ». On sait donc que le mot de passe qui correspond à cette empreinte est le quatrième de la chaîne. Comme on ne l'a pas stocké dans la table, nous allons régénérer la chaîne comme lors de la création de la table. On prend donc le mot de passe initial, on le fait passer dans la fonction de hachage, ce qui donne 05db7a98. Ensuite on fait passer cette empreinte dans la même fonction de réduction que celle qui a servi à générer la table. Elle retourne donc le deuxième mot de passe de la chaîne (jufx) que l'on hache puis réduit pour trouver le troisiième mot de passe (sgkj), que l'on hache puis réduit pour donner le quatrième mot de passe : « omhf ». Pour être sûr de nous, on hache « omhf », ce qui donne « 26c241b ». Nous avons cracké l'empreinte « 26c241b » : le mot de passe est « omhf ».

Essayons maintenant de cracker l'empreinte « 9d4e1e23 ». Elle ne figure pas dans la table. Essayons de calculer une autre empreinte à partir de « 9d4e1e23 ». Un appel à la fonction de réduction nous donne « swdv », qui si on le passe à la fonction de hachage renvoie « 4457806c ». Oh surprise… cette empreinte figure dans la table à la première ligne. Prenons donc le mot de passe initial « aaaa », et comme pour le premier cas, reconstituons la chaîne : 2 coups de hachage/réduction nous donnent le mot de passe « xccd » qui une fois passé au hachoir donne « 9d4e1e23 ». Mission accomplie. Le mot de passe correspondant à notre empreinte est « xccd ».

Une dernière empreinte à cracker : « 05db7a98 » :1. L'empreinte ne figure pas dans la table.2. reduce(hash(05db7a98)) donne 3caa59a1. Qui ne figure pas non plus dans la table.

Recommençons. 3. reduce(hash(3caa59a1)) donne a986fc2c. Encore perdu. Recommençons. 4. reduce(hash(a986fc2c)) donne 269c241b, qui figure sur dans la table, à la première ligne.

De plus comme nous avons tourné 3 fois pour trouver, et que la table contient des chaînes de longueur 4, le mot de passe recherché est le premier de la chaîne.

5. hash(qwer) donne 05db7a98. C'est gagné !

Pour stocker 100 millions de mots de passe, il suffit donc par exemple de générer une Rainbow table contenant 100'000 lignes avec des chaînes de longueur 1000. On stocke donc dans un fichier de



2 Mo une table qui pèserait 2 Go dans le cas d'un simple dictionnaire… si on a de la chance et pas de collisions !

CollisionsEn pratique, les fonctions de réductions provoquent des collisions. Une collision survient quand

la fonction de réduction retourne le même mot de passe pour deux empreintes différentes. Cela survient forcément car il y a toujours plus d'empreintes possibles que de mots de passe.

Nombre de mots de passe de 8 caractères alphanumériques : (26+26+10)8 = 528 = 5×1013 Nombre d'empreintes SHA-1 (160 bits) : 2160 = 104

Reprenons l'exemple précédent et admettons que nous n'ayons pas eu de chance. Cela donnerait à peu près cela :

La collision se produit lors de la réduction de 05db7a98. La fonction retourne « xccd », comme pour l'empreinte 4a388ce4. Résultat : au lieu de contenir 8 mots de passe distincts, notre table n'en contient que 6. Nous avons des chaînes qui sont dupliquées à partir de la collision (xccd → swdv).

Pour diminuer cet effet indésirable, les tables arc-en-ciel utilisent non pas une mais plusieurs fonctions de réduction (que l'on peut représenter par des couleurs différentes, d'où le nom « arc-en-ciel ». En fait, il y a une fonction de réduction différente par « colonne » :

Cette fois, même si une collision se produit, on ne se retrouve pas avec des chaînes dupliquées : on a seulement un mot de passe dupliqué. Évidemment, si on n'a vraiment pas de chance, on peut tomber sur une collision dans la même colonne. En pratique, il s'avère que ce cas n'arrive que rarement avec de longues chaînes.

Contre-mesuresL'efficacité des tables diminue de façon significative lorsque les fonctions de hachage sont



combinées à un sel. Dans le cadre d'un système de mots de passe, le sel est une composante aléatoire ou un compteur qui change en fonction de l'utilisateur. Si deux utilisateurs ont le même mot de passe, le sel permet d'éviter que les empreintes soient identiques. De manière informelle, le sel consiste en une opération du type :

empreinte = h(mot_de_passe + sel)

où l'opération + peut être une concaténation ou une opération plus complexe.Cette mesure augmente la complexité de l'attaque : il faut non seulement inverser la fonction

grâce aux tables mais il faut encore explorer l'ensemble des possibilités induites par la présence du sel. Si l'attaque réussit, il faut encore retirer le sel du mot de passe.

Le sel peut être le même pour tous les utilisateurs. Dans ce cas, il est conseillé d'ajouter le login de l'utilisateur avant de calculer l'empreinte.

En pratique, certaines applications n'utilisent pas de sel et sont vulnérables. En outre, le sel doit avoir une longueur suffisante pour augmenter sensiblement la complexité. Un sel trop court (par exemple 4 bits) ne multiplierait la complexité que d'un facteur de 16. Dans le système GNU/Linux, la fonction de hachage utilisée est du MD5 avec un sel de 8 caractères en ASCII ce qui rend l'attaque impossible en pratique.

10.5. Cryptographie moderneLa cryptographie (l'art de coder des messages) entre dans son ère moderne avec l'utilisation

intensive des ordinateurs, c'est-à-dire à partir des années septante. Dans la cryptographie moderne, on utilise aussi des problèmes mathématiques que l'on ne sait pas (encore) résoudre, par exemple factoriser des grands nombres (chiffre RSA) ou résoudre le problème général du sac à dos (chiffre de Merkle-Hellman).

10.5.1.Les systèmes à clefs publiquesDepuis les origines de la cryptographie, et jusqu'à récemment, tous les procédés étaient basés sur

une même notion fondamentale : chaque correspondant était en possession d'une clef secrète, qu'il utilisait pour chiffrer et déchiffrer. Cela a un inconvénient majeur : comment communiquer la clef au correspondant ? Il faut pour cela utiliser un canal sûr, par exemple une valise diplomatique. De toute manière, il faut un contact préalable avec la personne qui devra (dé)chiffrer nos messages.

Le milieu des années septante a vu l'avènement d'une nouvelle méthode de cryptage: le système à clefs publiques. L'idée de ce système a été proposée en 1976 par Diffie et Hellman, qui ont proposé une méthode totalement nouvelle : une clef pour chiffrer et une autre pour déchiffrer.

Bien entendu, il existe un lien mathématique entre ces deux clefs, mais ce lien est constitué par ce que les deux inventeurs appellent une « fonction trappe à sens unique ». Cette fonction permet de calculer aisément la clef de chiffrement en connaissant la clef de déchiffrement. En revanche, l'opération inverse est pratiquement impossible.

L'intérêt de ce système est considérable. En effet, toute personne ou toute entreprise disposant de moyens informatiques peut élaborer sa clef de déchiffrement - qu'elle garde secrète pour son usage exclusif - puis en déduire la clef de chiffrement correspondante. Tous les utilisateurs de ce système agissant de même, les clefs de chiffrement peuvent ensuite être groupées dans une sorte d'annuaire mis à la disposition du public. Ainsi, deux correspondants peuvent-ils communiquer secrètement sans aucun contact préalable. Les systèmes à clefs publiques les plus connus sont RSA et PGP, mais il en existe d'autres, par exemple le chiffre de Merkle-Hellman et le chiffre de Rabin.



Comme souvent dans l'histoire de la cryptographie, les vrais découvreurs ne sont pas toujours ceux que l'on pense. En effet, l'histoire a retenu les noms de Merkle, Hellman et Diffie car ils ont été les premiers a publié leur invention. En fait, on a appris plus tard que les trois premiers inventeurs de l'idée du système à clef publique était James Ellis, Clifford Cocks et Malcom Williamson, qui travaillaient au Government Communications Headquarters (GCHQ) de Cheltenham, établissement anglais top secret fondé sur les ruines de Bletchley Park après la Seconde Guerre mondiale.

Ellis posa les bases dès 1969. Puis, en 1973, Cocks eut une idée de ce qui serait plus tard connu sous le nom de chiffre asymétrique RSA. Il ne put mettre en œuvre son idée, car les ordinateurs de l'époque n'étaient pas encore assez puissants. En 1974, Cocks expose son idée à Williamson. Ce dernier, qui pense que cela est trop beau pour être vrai, reprend tout à zéro pour trouver une faille. Au lieu de cela, il trouve le système d'échange de clef de Diffie-Hellman-Merkle, à peu près en même temps que Martin Hellman. En 1975, Ellis, Cocks et Williamson avaient donc découvert tous les aspects fondamentaux de la cryptographie à clef publique, mais les trois anglais se turent, secret militaire oblige.

Nous avons pris des petits nombres pour faciliter les explications.

10.5.2.RSAL'implémentation fut achevée en 1978 par Rivest, Shamir et Adleman. Depuis, ce système de

chiffrement est appelé RSA, qui sont les initiales de ces trois chercheurs.

Rivest, Shamir et Adleman en 2003

On appellera Alice la personne qui désire recevoir un message chiffré, et Bob la personne qui envoie le message. La communication se déroule en trois étapes.

1. Choix de la clefAlice choisit deux grands entiers naturels premiers p et q (d'environ 100 chiffres chacun ou plus)

et fait leur produit n = p·q. Puis elle choisit un entier e premier avec (p−1)·(q−1). Enfin, elle publie, par exemple sur sa page web, sa clef publique : (RSA, n, e).

2. ChiffrementBob veut donc envoyer un message à Alice. Il cherche dans l'annuaire la clef de chiffrement

qu'elle a publiée. Il voit qu'il doit utiliser le système RSA avec les deux entiers n et e (prenons par exemple n=5141=53·97 et e=7, premier avec 52·96=4992). Il transforme en nombres son message en remplaçant par exemple chaque lettre par son rang dans l'alphabet.

« JEVOUSAIME » devient : « 10 05 22 15 21 19 01 09 13 05 »

Puis il découpe son message chiffré en blocs de même longueur représentant chacun un nombre plus petit que n. Cette opération est essentielle, car si on ne faisait pas des blocs assez longs (par exemple si on laissait des blocs de 2), on retomberait sur une substitution simple que l'on pourrait attaquer par une analyse des fréquences.

Son message devient : « 010 052 215 211 901 091 305 »



Chaque bloc B est chiffré par la formule C = Be mod n, où C est un bloc du message chiffré que Bob enverra à Alice.

Après avoir chiffré chaque bloc, le message chiffré s'écrit : « 0755 1324 2823 3550 3763 2237 2052 ».

3. DéchiffrementAlice calcule à partir de p et q, qu'elle a gardés secrets, la clef d de déchiffrage (c'est sa clef

privée). Celle-ci doit satisfaire l'équation e·d mod ((p-1)(q-1)) = 1. Le calcul de d n'est pas évident. Il faut utiliser l'algorithme d'Euclide étendu sur le site web compagnon et calculer 7-1 mod (52·96). On trouvera d=4279.

Chacun des blocs C du message chiffré sera déchiffré par la formule B = Cd mod n.

Elle retrouve : « 010 052 215 211 901 091 305 »

En regroupant les chiffres deux par deux et en remplaçant les nombres ainsi obtenus par les lettres correspondantes, elle sait enfin que Bob l'aime secrètement, sans que personne d'autre ne puisse le savoir.

Sécurité du RSASi une personne possède un moyen « rapide » de factoriser un nombre n, tous les algorithmes de

chiffrement fondés sur ce principe seraient remis en cause ainsi que toutes les données chiffrées dans le passé à l'aide de ces algorithmes.

La sécurité du système de cryptage RSA repose en effet sur la lenteur des algorithmes de factorisation connus et les laboratoires RSA Security soumettent depuis 1977 une liste de grands nombres assortie de récompenses pour les premières équipes capable de les factoriser.

Baptisés RSA suivi de leurs nombres de chiffres en écriture décimale ou binaire, les nombres proposés sont extrêmement difficile à casser et on estimait dans les années 80 qu'il faudrait des millions d'années pour y parvenir...

RSA-640 comprend 193 chiffres (décimaux) et n'a pourtant résisté en 2005 que quatre mois et demi au crible mis en œuvre par l'équipe allemande sur un réseau de 80 micro-processeurs Opteron cadencés à 2.2 GHz. Voici la factorisation de RSA-640 :

3107418240490043721350750035888567930037346022842727545720161948823206440518081504556346829671723286782437916272838033415471073108501919548529007337724822783525742386454014691736602477652346609

=1634733645809253848443133883865090859841783670033092312181110852389333100104508151212118167511579

x1900871281664822113126851573935413975471896789968515493666638539088027103802104498957191261465571

10.6. AuthentificationLa signature numérique (ou électronique) est un code qui authentifie

l'auteur d'un message ou d'une transaction électronique. Le but est de fournir un moyen à l'expéditeur de pouvoir lier son identité à une information.

Son fonctionnement général est l'inverse du système à clé publique et implique aussi la paire de clés publique/privée. Quelqu'un voulant assurer le destinataire qu'il est bien l'expéditeur chiffrera son message avec sa clé privée et le destinataire déchiffrera le message chiffré avec la clé publique correspondante de l'expéditeur. Habituellement, pour réduire la taille des messages, une fonction de hachage est utilisée pour créer une empreinte du message et c'est cette empreinte que l'on chiffre.



Le scellement des données L'utilisation d'une fonction de hachage permet de vérifier que l'intégrité du message a été

préservée. Cependant, rien ne prouve que le message a bien été envoyé par celui que l'on croit être l'expéditeur.

Pour garantir l'authentification du message, Alice chiffre le haché à l'aide de sa clé privée (le haché signé est appelé sceau). Elle envoie ensuite à Bob son message accompagné du sceau.

À la réception du courriel, Bob déchiffrera le sceau avec la clé publique d'Alice ; il obtiendra ainsi le message haché par Alice. Il hachera ensuite le message d'Alice et comparera les deux hachés. Si les deux hachés sont identiques, cela signifie que le message a bien été envoyé par Alice. Ce mécanisme de création de sceau est appelé scellement.

En pratiqueDans les logiciels de courrier électronique, cette signature prend la forme d'une suite plus ou

moins longue de caractères sans signification, qui est parfois visible à la fin du message. Cette signature est encodée par une clé privée que seul l'expéditeur détient. Le logiciel du destinataire reconstitue la signature de l'expéditeur à l'aide de la clé publique de l'expéditeur qu'il trouve dans un répertoire de clés publiques. Si la signature est bien décodée, le destinataire est certain que le message provient de l'expéditeur, car seul ce dernier a pu, avec sa clé privée, encoder sa signature. Le logiciel PGP (Pretty Good Privacy) utilise ce procédé et se greffe aux logiciels de courrier électronique les plus répandus.

Dans le commerce électronique, la signature numérique empêche la fraude, car elle authentifie automatiquement l'identité d'un commerçant qui offre des produits sur Internet et celle d'un client qui passe une commande.

Sources[1] Wikipédia, « Portail de la sécurité informatique »,

<http://fr.wikipedia.org/wiki/Portail:Sécurité_informatique>

[2] Comment ça marche, « Sécurité/Législation », <http://www.commentcamarche.net/contents/security/>

[3] « Virus informatiques », <http://vaccin.sourceforge.net/index.php>

[4] Mieux coder, « Rainbow tables », <http://www.mieuxcoder.com/2008/01/02/rainbow-tables/>

[5] Ars Cryptographica, <http://www.apprendre-en-ligne.net/crypto>


http://www.apprendre-en-ligne.net/crypto

http://www.mieuxcoder.com/2008/01/02/rainbow-tables/

http://vaccin.sourceforge.net/index.php

http://www.commentcamarche.net/contents/security/

http://fr.wikipedia.org/wiki/Portail:S%C3%A9curit%C3%A9_informatique

L'informatique au lycée Annexes

AnnexesA.1. La notation O(f(n))

Dans les années 1960 et au début des années 1970, alors qu'on en était à découvrir des algorithmes fondamentaux, on ne mesurait pas leur efficacité. On se contentait de dire, par exemple : « Cet algorithme se déroule en 6 secondes avec un tableau de 50'000 entiers choisis au hasard en entrée, sur un ordinateur IBM 360/91. Le langage de programmation PL/I a été utilisé avec les optimisations standards. »

Une telle démarche rendait difficile la comparaison des algorithmes entre eux. La mesure publiée était dépendante du processeur utilisé, des temps d'accès à la mémoire vive et de masse, du langage de programmation et du compilateur utilisé, etc.

Une approche indépendante des facteurs matériels était nécessaire pour évaluer l'efficacité des algorithmes. Donald Ervin Knuth (1938-) fut un des premiers à l'appliquer systématiquement dès les premiers volumes de sa fameuse série The Art of Computer Programming.

La notation grand O (avec la lettre majuscule O, et non pas le chiffre zéro) est un symbole utilisé en mathématiques, notamment en théorie de la complexité, pour décrire le comportement asymptotique des fonctions.

Une fonction g(n) est dite O(f(n)) s'il existe un entier N et une constante réelle positive c tels que pour n > N on ait g(n) ≤ c·f(n).

En d'autres termes, O(f(n)) est l'ensemble de toutes les fonctions g(n) bornées supérieurement par un multiple réel positif de f(n), pour autant que n soit suffisamment grand.

Par exemple, f(n)=(n−1)2 est O(n2), et g(n) = n l'est aussi. Attention, g(n) est O(f(n)) ne veut pas dire que g(n) s'approche asymptotiquement de f(n), mais seulement qu'au-delà de certaines valeurs de son argument, g(n) est dominé par un certain multiple de f(n).

Notation Type de complexité

O(1) complexité constante (indépendante de la taille de la donnée)

O(log(n)) complexité logarithmique

O(n) complexité linéaire

O(n.log(n)) complexité quasi-linéaire

O(n2) complexité quadratique

O(n3) complexité cubique

O(np) complexité polynomiale

O(nlog(n)) complexité quasi-polynomiale

O(2n) complexité exponentielle

O(n!) complexité factorielle

Didier Müller A-1 novembre 2010

Annexes

Quelques courbes de complexité

ExerciceExerciceParmi les affirmations suivantes, lesquelles sont vraies ?

f(n) g(n) f est O(g) g est O(f)

n+1 n4+3n−2

n+4 4n

n3

10100 n2 n3

2n+1 2n

22n 2n

(n+a)b nb

nn n!

2n n!

SourceWikipédia, « Théorie de la complexité des algorithmes »,<http://fr.wikipedia.org/wiki/Théorie_de_la_complexité_des_algorithmes>

Didier Müller A-2 août 2010

http://fr.wikipedia.org/wiki/Th%C3%A9orie_de_la_complexit%C3%A9_des_algorithmes