Cours Univ Nanates

Cours d'Informatique
Diplôme d'Etudes Universitaires
Générales
Sciences et Technologie
Christophe Mauras
Université de Nantes, UFR Sciences et Techniques
4 octobre 2000
● 1 Introduction
● 2 Qu'est ce que l'informatique ?
❍ 2.1 Points de vue
❍ 2.2 Communiquer, coder, traiter
❍ 2.3 L'ordinateur
❍ 2.4 Algorithmes, programmes et langages
❍ Exercices
● 3 Communiquer de l'information
❍ 3.1 Communication homme-machine
❍ 3.2 Communication entre ordinateurs : les réseaux
❍ 3.3 Programmer la communication
❍ Exercices
❍ Corrigés et indications
● 4 Représenter l'information
❍ 4.1 Codages
❍ 4.2 Programmer avec différents types d'informations
❍ 4.3 Fichiers et formats
❍ 4.4 Enjeux de société
http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours.html (1 of 3) [16-11-2001 19:51:15]

❍ Exercices
● 5 Traiter l'information
❍ 5.1 Un exemple : le traitement de texte
❍ 5.2 Un exemple de traitement générique : le tableur
❍ 5.3 Programmer
❍ Exercices
● 6 Commencer à programmer
❍ 6.1 Traitements conditionnels
❍ Exercices
❍ 6.2 Traitements répétitifs
❍ Exercices
❍ 6.3 Traitements de tableaux
❍ Exercices
● 7 Pour bien programmer
❍ 7.1 Décomposer les traitements
❍ 7.2 Fonctions et procédures
❍ Exercices
❍ 7.3 Analyser les traitements répétitifs
❍ Exercices
● 8 Pour aller plus loin
❍ 8.1 Domaines d'application de l'informatique
❍ 8.2 La tour de Babel
❍ 8.3 Théories fondamentales
● 9 En conclusion
● References
● Index

● Glossaire
● A Annexes
● 10 Informations sur quelques logiciels d'usage courant
● 11 Référence rapide du langage Pascal
❍ Syntaxe
❍ Déclarations et types
❍ Compilation et exécution
● 12 Référence rapide du langage JavaScript
❍ Syntaxe du langage JavaScript
❍ Interprétation d'un programme JavaScript
● 13 Quelques commandes de base des systèmes d'exploitation
© Christophe Mauras, Université de Nantes, 4 octobre 2000

Cours d'Informatique -- 1 Introduction
Up Next
Remonter : Top
Suivant : 2 Qu'est ce que l'informatique ?
1 Introduction
Ce cours est une initiation à l'informatique, qui ne suppose aucun pré-requis spécifique. Il s'adresse à tout
public ayant une formation secondaire scientifique ou technique. Il s'adresse en priorité aux stagiaires en
formation continue et aux étudiants de premier cycle universitaire, souhaitant découvrir l'informatique,
en tant que discipline scientifique.
Le document est conçu pour amener le lecteur à comprendre progressivement ce qu'est l'informatique,
ses outils les plus connus, mais aussi les techniques et théories sous-jacentes, puis à découvrir l'envers du
décor : comment ça marche ?
Les parties du document consacrées à la programmation tenteront ainsi d'expliquer le "comment", en
accompagnant le lecteur dans l'écriture de programmes de plus en plus complexes.
De nombreux compléments techniques, historiques, culturels sont présents pour familiariser le lecteur
avec l'informatique, en l'aidant à en déchiffrer le "jargon". Le document se termine par une ouverture
destinée à baliser le champ d'intervention de l'informatique, et ses problématiques principales.
Parmi les ouvrages d'initiation à l'informatique on pourra aussi consulter [BDH90] (ouvrage très
accessible, qui était destiné à l'option informatique des lycées), et pour la partie "conception
d'algorithmes", [SFLM93] (ouvrage de référence, mais dont le programme dépasse celui de ce cours)
ainsi que [CK95][PB88][BC84].
Les exemples de programmes seront écrits dans les langages Pascal ou JavaScript, pour lesquels outre les
annexes, on pourra consulter pour Pascal [Gra99][Cou92] et pour JavaScript [Fla00][Cor99].
Remerciements
Ce cours a bénéficié de l'expérience de toute l'équipe pédagogique d'informatique en Deug Sciences,

depuis une dizaine d'années. Qu'ils en soient tous ici remerciés et en particulier François Alliaume et
Didier Robbes pour leur relecture attentive de ce document.
Up Next
http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_1.html [16-11-2001 19:51:25]

Cours d'Informatique -- 2 Qu'est ce que l'informatique ?
Prev Up Next
Précédent : 1 Introduction
Remonter : Top
Suivant : 3 Communiquer de l'information
2 Qu'est ce que l'informatique ?

Le mot apparaît dans le Journal Officiel du 17 Janvier 1982 avec la définition suivante :
Informatique : science du traitement rationnel, notamment par machines automatiques, de
l'information considérée comme le support des connaissances humaines et des communications dans les
domaines technique, économique et social
Bien que de lecture difficile, cette définition encyclopédique a le mérite de préciser les points suivants :
● Il s'agit d'une science, qui repose donc sur des théories, qui permettront donc, entre autres choses,
de prévoir le comportement d'un ordinateur : l'aléatoire n'a pas de place en informatique, seule
l'ignorance peut faire croire à l'aléatoire.
● Le traitement doit être rationnel, on s'attachera à ce que la création d'un programme le soit aussi,
en utilisant des méthodes précises.
● Par machine automatique, on entendra : machine capable de reproduire automatiquement un
traitement qu'elle aura mémorisé au préalable, c'est-à-dire par exemple, un ordinateur.
● La notion d'information en tant que support des connaissances est très large : elle englobe tout ce
que l'on pourrait, écrire, mais aussi dire, dessiner...En fait elle s'applique parfaitement à ce que
l'informatique peut manipuler aujourd'hui : des nombres, des textes, mais aussi des sons, des
images, des enregistrements vidéo, des mesures physiques ...
● Les domaines d'application (technique, économique et social) possibles recouvrent une grande
partie des activités humaines. Ceci est bien sûr confirmé par l'informatisation croissante de la
société, que l'on ne peut que constater (ceci sans jugement de valeur).
Mais toutes ces définitions seraient incomplètes, si on ne les agrémentait de points de vue choisis, pour
en montrer les différents visages.
● 2.1 Points de vue
● 2.2 Communiquer, coder, traiter

● 2.3 L'ordinateur
● 2.4 Algorithmes, programmes et langages
● Exercices

Prev Up Next

Cours d'Informatique -- References
Prev Up Next
Précédent : 9 En conclusion
Remonter : Top
Suivant : Index
References
[AFL+00]
P. Amblard, J.C. Fernandez, F. Lagnier, F. Maraninchi, P. Sicard, and P. Waille. Architectures
logicielles et matérielles. Dunod, 2000.
[BC84]
J. Biondi and G. Clavel. Introduction à la programmation. 1984.
[BDH90]
Ph. Breton, G. Dufourd, and E. Heilmann. L'option informatique au lycée. Hachette, 1990.
[Bel98]
P. Bellot. Logique et automates. Ellipses, 1998.
[Bro99]
J. Brondeau. Introduction à la programmation objet en Java. Dunod, 1999.
[CK95]
J. Courtin and I. Kowalski. Initiation à l'algorithmique et aux structures de données (en 3
volumes). Dunod, 1995.
[Cor99]
Netscape Communications Corporation. JavaScript Reference.
http://developer.netscape.com/docs/manuals/js/client/jsref/index.htm, 1999.
[Cou92]
P. Cousot. Algorithmique et programmation en Pascal. Ellipse, 1992.
[DGL]
Vocabulaire de l'informatique et de l'internet, Journal officiel du 16 mars 1999, Journal officiel du
10 octobre 1998. Commission générale de terminologie et de néologie. Consultable à l'adresse:
http://web.culture.fr/culture/dglf/.
[Fla00]
D. Flanagan. JavaScript Précis et concis. O'Reilly, 2000.
[Gra99]
Y. Granjon. Informatique: algorithmes en Pascal et en langage C. Dunod, 1999.
[Kra85]
S. Krakowiak. Principe des systèmes d'exploitation des ordinateurs. Dunod, 1985.
http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_86.html (1 of 2) [16-11-2001 19:51:34]

Cours d'Informatique -- References
[MAd99]
Révolution dans la communication, Les grands défis d'Internet. Manière de voir n° 46, aout 1999.
[PB88]
P. Perlioux and P. Bizard. Algorithmique (en 2 volumes). Dunod, 1988.
[SFLM93]
P.C. Scholl, M.C. Fauvet, F. Lagnier, and F. Maraninchi. Cours d'informatique : langages et
programmation. Masson, 1993.
[Tan99]
A. Tanenbaum. Systèmes d'exploitation : systèmes centralisés, systèmes distribués. Dunod, 1999.
[TSI99]
Technologies et société de l'information. Secrétariat d'Etat à l'industrie, Mars 1999.
[WL99]
P. Weiss and X. Leroy. Le langage caml. Dunod, 1999.
[Xuo92]
N. H. Xuong. Mathématiques discrètes et informatique. Masson, 1992.
Prev Up Next

Cours d'Informatique -- 3 Communiquer de l'information
Prev Up Next
Précédent : 2 Qu'est ce que l'informatique ?
Remonter : Top
Suivant : 4 Représenter l'information
3 Communiquer de l'information
L'information contenue dans un ordinateur, peut être transmise à un autre ordinateur ou être
communiquée à l'utilisateur sous une forme appropriée (lisible). La représentation binaire de
l'information (0, 1) permet de repliquer, sans perte d'information, et de communiquer la même
information à un ou plusieurs interlocuteurs.
Ces propriétés font de l'ordinateur - éventuellement connecté à d'autres ordinateurs - un outil de
communication très puissant.
Pour qu'il y ait "communication", il doit y avoir un "locuteur" (celui qui parle) et un "récepteur" (celui
qui écoute). Pour que la communication soit utile, il faut que le récepteur comprenne le langage du
locuteur (ou au moins fasse mine de le comprendre). Si la communication a lieu dans les deux sens,
chacun peut jouer alternativement chacun des deux rôles.
Concernant la communication entre l'homme (en général, sans connotation sexiste) et la machine, elle est
inévitablement stéréotypée, car elle est restreinte à ce que l'ordinateur peut "comprendre" (ce qui a été
prévu dans son programme) et à ce qu'il peut "dire".
Entre deux ordinateurs, la situation est plus équilibrée, les deux ordinateurs communiquant devant
seulement partager le même langage stéréotypé, et être d'accord sur les modalités de la communication :
on parlera de "protocole" pour désigner les règles indiquant ce que l'un doit répondre à l'autre dans une
situation particulière.
Pour prévoir ce que dira, ou "comprendra" (acceptera d'entendre) un ordinateur, on peut le spécifier dans
son programme : ceci a d'ailleurs été déjà utilisé dans l'exemple d'algorithme.
● 3.1 Communication homme-machine
● 3.2 Communication entre ordinateurs : les réseaux
● 3.3 Programmer la communication
● Exercices
● Corrigés et indications

Prev Up Next

Cours d'Informatique -- 2.1 Points de vue
Up Next
Remonter : 2 Qu'est ce que l'informatique ?
Suivant : 2.2 Communiquer, coder, traiter
2.1 Points de vue

● "Je fais de l'informatique : je connais Word2000, Micro-Windows99, Soft-Office", Robert,
secrétaire, 38 ans.
● "Moi, l'informatique, j'y comprends rien", Georges, 56 ans, ouvrier Renault en pré-retraite,
remplacé par un robot.
● "Je crois qu'à la fin de ce siècle, l'usage des mots et l'opinion publique auront tellement évolué,
qu'on pourra parler de machines qui pensent sans crainte d'être contredit" Alan Turing, 1950, (un
des pères fondateurs de l'informatique, qui en disant cela s'était trompé).
● "ouaih ! je connais ...les jeux vidéos, internet ..." Kevin, 16 ans, lycéen, 1999.
● "Je suis désolé, Monsieur, mais puisque je vous dis que l'ordinateur s'est trompé", employé
anonyme au téléphone.
Pour tenter de répondre à la question : "Qui fait de l'informatique", on peut distinguer les groupes
suivants, (sans que leurs frontières ne soient réellement étanches) :
● Les utilisateurs : de minitel, d'internet, de logiciels en tout genre. Evidemment, les utilisateurs ne
font pas plus d'informatique, que les conducteurs ne font de la mécanique automobile. S'ils doivent
parfois en comprendre quelques subtilités, ce peut être à cause des suivants qui ont omis de rédiger
correctement le mode d'emploi.
● Les initiés. Ayant découvert "comment ça marche", par exemple en étant initié à la
programmation, l'initié peut dialoguer avec un informaticien (ce qui n'est pas si simple),
comprendre ce qu'un ordinateur peut ou ne peut pas faire, utiliser certains progiciels
"programmables" (c'est le cas des tableurs et de certains systèmes de gestion de base de données),
ou participer à des développements en informatique. Ce genre de compétences est surtout
recherchée quand il s'agit d'une "double compétence" alliée à une compétence professionnelle dans
un autre domaine. Ce cours a pour objectif d'initier, et éventuellement d'ouvrir la voie à une
formation d'informaticien.
● Les informaticiens ont la charge de définir des traitements rationnels, sur des machines
automatiques, de l'information ...Ils peuvent travailler sur le matériel et/ou le logiciel, dans divers
types d'entreprises (PME-PMI, SSII ...) ou administrations, et assumer diverses fonctions
(analyste, chef de projet, formateur, technicien de maintenance ...).
Up Next

Cours d'Informatique -- 2.2 Communiquer, coder, traiter
Prev Up Next
Précédent : 2.1 Points de vue
Suivant : 2.3 L'ordinateur
2.2 Communiquer, coder, traiter

Le paradigme fondamental de l'informatique consiste à :
● coder les informations fournies (avec des 0 et des 1)
● faire des traitements sur ces codes, de manière automatique, selon les instructions d'un programme,
jusqu'à obtenir un résultat codé,
● éventuellement communiquer les informations codées (avant ou après le traitement)
● restituer des informations compréhensibles en décodant le résultat.
Exemple : si on choisit, arbitrairement de coder les entiers 2, 3 et 5 respectivement par 00100, 10000
et 10100, si l'ordinateur dispose d'un dispositif électronique avec 10 fils en entrée et 5 en sortie
transformant 0010010000 en 10100, alors en décodant le résultat, on obtient 5. Peux-t-on en déduire
que l'ordinateur "sait" que 2 plus 3 font 5 ? On peut seulement en déduire que le codage et le traitement
ont été choisis judicieusement, pour ensemble produire le résultat escompté.
Voilà pourquoi, il ne peut y avoir d'intelligence dans un ordinateur. Tout n'y est que simulation.
L'apparence d'intelligence vient uniquement de la complexité (le très grand nombre) des informations
élémentaires mémorisées, et de la rapidité des traitements élémentaires sur ces informations.
La maîtrise de cette complexité (circuit intégré avec plusieurs millions de transistors, programmes longs
de plusieurs milliers de lignes) est l'enjeu majeur de l'informatique, et la raison principale qui motive les
évolutions de l'ingénierie informatique.
Le second principe fondamental d'un ordinateur, ce qui le différencie d'une calculette ou d'une machine
mécano-graphique, a été introduit par Von Neumann en 1945 : l'ordinateur exécute, pour traiter les
informations qu'il a en mémoire, les instructions d'un programme, lui même enregistré en mémoire.
C'est ce principe qui donne à l'ordinateur sa polyvalence - il suffit de changer le programme pour traiter
d'autres informations - et sa puissance : l'ordinateur peut aussi modifier ses propres programmes ...à
condition d'avoir été programmé pour cela (à noter que le programmeur est ainsi définitivement préservé
du risque mythique d'être dépassé par l'ordinateur).
C'est toujours l'architecture "de Von Neumann", qui préside à la conception des ordinateurs modernes.
Prev Up Next

Cours d'Informatique -- 2.3 L'ordinateur
Prev Up Next
Précédent : 2.2 Communiquer, coder, traiter
Suivant : 2.4 Algorithmes, programmes et langages
2.3 L'ordinateur
Un ordinateur est donc une machine automatique (le plus souvent électronique) capable de coder,
mémoriser, traiter et communiquer l'information.
L'aspect extérieur d'un ordinateur peut varier considérablement selon sa taille, et son usage. On peut
distinguer :
● Les ordinateurs personnels (en anglais : personal computer, PC) et les portables : toutes les
fonctions de communication (écran, clavier, souris) de mémorisation (disque dur ...) et de calcul
sont regroupés dans un espace restreint. Un seul utilisateur utilise toutes les ressources de la
machine.
● Les mini-ordinateurs (qui, miniaturisation aidant, ne sont pas nécessairement plus encombrants) se
distinguent par le fait qu'ils sont dédiés à servir de nombreux utilisateurs, travaillant chacun devant
un terminal ou une "station de travail". Leur possibilités de communication sont importantes,
chacun des postes de travail, comportant au moins un clavier et un écran, étant relié au
mini-ordinateur par un réseau. On les appelle aussi "serveurs", car ces mini-ordinateurs
concentrent de grandes capacités de stockage et de calcul, au service de leurs utilisateurs.
● Les "grands systèmes" (main-frames, en anglais) : apparus dans les années 65, ces grands systèmes
(qui occupaient une salle entière, climatisée) se caractérisaient par la centralisation de leurs
traitements, et étaient principalement dédiés aux grandes applications de gestion (bancaire ...).
● Les ordinateurs industriels (qui contrôlent un processus de fabrication ou des robots) et ordinateurs
embarqués (à bord de véhicules, avions, fusées, satellites) ont la particularité d'avoir des dispositifs
de communication spécifiques (capteurs, actionneurs ...), n'ont pas nécessairement de
clavier-écran, et peuvent être situés dans un environnement "hostile" (vibrations, ondes
électro-magnétiques, humidité ...).
Il faut de plus noter que, les progrès technologiques aidant (le moindre ordinateur personnel actuel à des
capacités de stockage et de traitement largement supérieures à celles des grands systèmes des années 70),
la tendance actuelle étant de connecter de plus en plus d'ordinateurs en réseau, on doit alors s'intéresser
aux capacités d'un ensemble d'ordinateurs plutot que d'un ordinateur isolé.
Cependant la structure interne d'un ordinateur obéit toujours à l'architecture "de Von Neumann" que l'on
peut décrire ainsi :
● Architecture d'un ordinateur

Prev Up Next

Cours d'Informatique -- 2.4 Algorithmes, programmes et langages
Prev Up Next
Précédent : 2.3 L'ordinateur
Suivant : Exercices
2.4 Algorithmes, programmes et langages

Un ordinateur dispose de son programme enregistré en mémoire : ce programme est donc écrit dans le
seul langage directement compris par la machine, à savoir le langage binaire. Dans ce langage, un code
est choisi (par le constructeur) pour chacune des instructions de base de l'ordinateur :
● les instructions de transfert entre la mémoire et l'unité de calcul, (par exemple : "charger dans
l'unité de calcul l'information présente à telle adresse")
● les instructions de calcul (arithmétique, logique ...)
● les instructions de contrôle (par exemple : "continuer par le programme situé à telle adresse si le
résultat du calcul précédent est positif")
Ecrire des programmes en mettant bout à bout de telles instructions, puis les traduire en leur code binaire
s'est vite révélé extrêmement fastidieux. Fort heureusement, dès les débuts de l'informatique, sont
apparus des "langages de programmation", permettant de décrire symboliquement les traitements à
effectuer. Un programme appelé "compilateur" est alors chargé de transformer automatiquement le
programme écrit par l'utilisateur en une suite de codes compréhensibles par l'ordinateur.
Un langage de programmation particulier (il en existe de très nombreux) est défini par :
● sa syntaxe, c'est-à-dire la "forme" que devront avoir les programmes pour pouvoir être traduits
automatiquement par le compilateur (par exemple : commencer par tel mot-clé : "program" en
langage Pascal ...)
● sa sémantique, c'est-à-dire son "sens", ou "ce que tel programme fera faire à l'ordinateur, quand il
sera exécuté".
Chaque langage de programmation définit ainsi (par l'usage de mots clés comme : begin, end, if ...,
par des règles de construction) la forme particulière que devront avoir les programmes écrits dans ce
langage. La difficulté majeure pour le programmeur peut alors être le respect de cette forme imposée, qui
de plus change d'un langage à un autre.
Il est alors apparu l'usage, pour privilégier le fond sur la forme, d'écrire ce que l'on appelle des
"algorithmes".
Algorithme : transcription dans un langage non ambigu, pour le lecteur humain, de la méthode
informatique de résolution d'un problème.
L'algorithme est destiné à transmettre, à mémoriser ou à expliquer cette méthode.
Charge au programmeur, ensuite de traduire son algorithme dans le langage de programmation qu'il
souhaite utiliser, en en respectant les règles de forme. Dans le cadre de ce cours, les langages de
programmation utilisés seront Pascal et JavaScript.

Cours d'Informatique -- 2.4 Algorithmes, programmes et langages
Pour un tour d'horizon des langages de programmation, on visitera la tour de Babel.

● Exemple d'algorithme

Prev Up Next

Cours d'Informatique -- Exercices
Prev Up
Précédent : 2.4 Algorithmes, programmes et langages
Exercices
Exercice 2.1 : Lire un descriptif d'ordinateur personnel
Il est parfois difficile de s'y retrouver dans les documentations d'ordinateurs fournies par les revendeurs.
Voici un exemple de configuration d'un ordinateur personnel.
Chercher dans cette descriptions, les caractéristiques suivantes:
● Le type et la vitesse du processeur
● Les différentes composantes de la mémoire et leur capacité
● Les différentes unités de communication
Ordinateur personnel :
● Composants
❍ Intel Pentium III à 450 MHz
❍ Chipset PCI Intel 440BX, bus système à 100 MHz
● Mémoire
❍ 64 Mo de mémoire (SDRAM 100MHz) extensible à 384 Mo (3 emplacements DIMM)
❍ 512 Ko de mémoire cache intégrée au processeur
● Stockage
❍ Contrôleur EIDE Ultra DMA (33 Mo/s) intégré
❍ Disque dur 6,4 Go SMART II
❍ Unité de disquette 3" - 1,44 Mo
● Réseau
❍ Chipset réseau Ethernet PCI 3COM 3C916 - 10/100 MB intégré - RJ 45
● Connecteurs
❍ 1 slot ISA, 1 slot PCI , 1 slot partagé ISA/PCI
❍ 1 port parallèle (ECP), 2 ports série, 1 port souris et 1 port clavier PS/2, 2 ports USB
● Multimédia
❍ Chipset son Crystal CS4236-B intégré
❍ Lecteur de CD-ROM 17/40x IDE
● Affichage
❍ Contrôleur vidéo avec 4 Mo de mémoire vidéo SGRAM à 100 MHz extensible à 8 Mo
❍ Moniteur couleur 17"

● Divers
❍ Clavier 105 touches français
❍ Souris
Exercice 2.2 : Capacité mémoire et débits

En reprenant les caractéristiques ci-dessus, calculer:
● le nombre de disquettes qui seraient nécéssaires à une sauvegarde complète du disque dur, celui-ci
étant supposé entièrement "rempli".
● le temps nécessaire pour lire sur le disque dur, l'équivalent d'une disquette. Tenir compte pour ce
calcul du débit indiqué pour le "contrôleur de disque".
● la taille de la diagonale de l'écran en centimètres, sachant qu'elle est exprimée en pouces (1 pouce
= 2.54 centimètres).
Exercice 2.3 : Les métiers d'informaticien
Rechercher, sur Internet (par exemple sur le serveur du journal Le Monde) ou dans les quotidiens, des
offres d'emploi dans le domaine de l'informatique, ou comportant des mots-clés y faisant référence.
Parmi les annonces collectées, lesquelles demandent une formation d'informaticien ? Quels sont les
domaines d'activités et les compétences demandées ?
Prev Up

Cours d'Informatique -- 4 Représenter l'information
Prev Up Next
Précédent : 3 Communiquer de l'information
Remonter : Top
Suivant : 5 Traiter l'information
4 Représenter l'information
La notion d'information utilisée en informatique est le support de connaissances pouvant être exprimées
par des textes, des nombres, des images, des enregistrements sonores ou vidéo...
L'ordinateur pour représenter et mémoriser ces informations, utilise toujours le codage binaire (qui ne
contient que les 2 valeurs : 0 et 1). Quand on parle de "technologie numérique" ou "digitale", de "son
numérique" ou de "photos numériques", cela fait référence au codage binaire qui est alors utilisé pour
représenter les informations. L'informatique a introduit massivement ces technologies dites
"numériques", en opposition à la "technologie analogique" selon laquelle une grandeur (le volume d'un
son par exemple) est représentée - par analogie - par une autre grandeur continue proportionnelle à la
première (l'intensité d'un champ magnétique par exemple, dans un magnétophone à cassettes). Le
numérique a l'avantage sur l'analogique de ne pas craindre de petites altérations: un chiffre binaire vaut 0
ou 1 mais jamais 0,99. Une information numérisée (codée en binaire) peut ainsi être copiée à l'identique.
Un octet contient 8 chiffres binaires (en abréviation bit, pour BInary digiT): on a ainsi 28 = 256 valeurs
différentes pour un octet : 00000000, 00000001, 00000010, 00000011, 00000100 ...
Pour représenter moins de 256 informations différentes, on peut donc se contenter d'un octet : il suffit
alors de choisir arbitrairement quel code attribuer à quelle information. C'est ce qui est fait pour les
caractères. Bien que totalement arbitraire, un codage a cependant intérêt à être partagé par le plus grand
nombre possible d'ordinateurs; en effet ce sont les codes qui sont transmis lors de communications entre
ordinateurs, d'où l'intérêt des normalisations.
Pour représenter plus d'informations ou des informations plus complexes, la solution consiste à utiliser
autant d'octets que nécessaire, rangés les uns après les autres dans la mémoire de l'ordinateur.
Exemple : pour représenter une photo numérique d'un format de 1024 par 1024 points, chacun pouvant
être d'une couleur à choisir parmi 256 couleurs, il faut, pour chaque point de l'image, mémoriser sa
couleur : un octet suffit pour un point. L'image comportant 1024 lignes comportant chacune 1024 points,
il faut alors au total : 1024 * 1024 octets, soit 1 Méga-octet (Mo) de mémoire.
Exemple : pour représenter un texte écrit (sans information de mise en page), que l'ordinateur considère
comme une suite de caractères (alphabétiques, symboles de ponctuation, espaces et passages à la ligne),
il faut autant d'octets que le texte comporte de caractères. Pour un texte de 1000 pages, comportant en
moyenne 1000 caractères par page, il faut alors 1000000 d'octets, soit presque 1 Mo. Pour comparaison,
si le texte est digitalisé (par un scanner couleur), on obtient alors une photo pour chaque page, ce qui
occupe alors de l'ordre de 1 Mo pour chaque page !

Cours d'Informatique -- 4 Représenter l'information
Ces deux exemples donnent une idée - approximative, mais cependant significative - des ordres de
grandeur de la "quantité d'information" qu'un ordinateur peut manipuler. Notons que la différence
évoquée entre un texte et une photo, explique la rapide percée des ordinateurs multimédia, au moment
(début des années 90) où la technologie de fabrication des mémoires à permis de réaliser des mémoires
de grande capacité.
● 4.1 Codages
● 4.2 Programmer avec différents types d'informations

● 4.3 Fichiers et formats
● 4.4 Enjeux de société
● Exercices

Prev Up Next

Cours d'Informatique -- 5 Traiter l'information
Prev Up Next
Précédent : 4 Représenter l'information
Remonter : Top
Suivant : 6 Commencer à programmer
5 Traiter l'information
Les traitements d'informations qu'un ordinateur peut effectuer, sont de natures très différentes - les
informations elles-même pouvant être de différentes natures.
Du point de vue de l'utilisateur d'un programme (d'un "logiciel"), ces traitements peuvent apparaître
complexes. Cependant, ils sont toujours définis en composant des traitements élémentaires.
Logiciel : "produit informatique" destiné à effectuer des traitements informatiques et à être diffusé à ses
utilisateurs, sous la forme d'un programme (ou un ensemble de programmes) exécutables.
Parmi les logiciels les plus usuels, dans le domaine de la "bureautique", on peut citer le traitement de
texte, le tableur, le système de gestion de base de données ...Leur utilisation peut être simplement décrite,
sans se référer à leur programme. Ceci est bien sûr préférable, car le plus souvent l'utilisateur ne peut pas
lire le programme de son logiciel ; d'ailleurs cela pourrait ne pas l'intéresser du tout !
Si on adopte le point de vue du programmeur, on comprend alors qu'un traitement complexe sur une
information complexe, se programme en composant des traitements élémentaires sur les informations
élémentaires composant l'information complexe. Et qu'un logiciel n'est jamais qu'un gros (très gros)
programme ...
● 5.1 Un exemple : le traitement de texte
● 5.2 Un exemple de traitement générique : le tableur

● 5.3 Programmer
● Exercices

Prev Up Next

Cours d'Informatique -- Glossaire
Prev Up Next
Précédent : Index
Remonter : Top
Suivant : A Annexes
Glossaire
D'après les termes recommandés par [DGL].
Cliquer :
enfoncer et relâcher le bouton-poussoir (ou cliquet) d'une souris ou d'un dispositif similaire.
Connexion :
procédure permettant à un utilisateur de se mettre en relation avec un système informatique et, si

nécessaire, de se faire reconnaître de celui-ci.
Fenêtre :
partie rectangulaire de l'écran d'un ordinateur à l'intérieur de laquelle sont affichées les informations
relatives à une activité déterminée. Équivalent étranger : window
Hypertexte :
système de renvois permettant de passer directement d'une partie d'un document à une autre, ou d'un
document à d'autres documents choisis comme pertinents par l'auteur. Équivalent étranger : hypertext.
Icône :
sur un écran, symbole graphique qui représente une fonction ou une application logicielle particulière
que l'on peut sélectionner et activer au moyen d'un dispositif tel qu'une souris.
Internet :
réseau mondial associant des ressources de télécommunication et des ordinateurs serveurs et clients,
destiné à l'échange de messages électroniques, d'informations multimédias et de fichiers. Il fonctionne en
utilisant un protocole commun qui permet l'acheminement de proche en proche de messages découpés en
paquets indépendants.
Logiciel de navigation :
dans un environnement de type internet, logiciel qui permet à l'utilisateur de rechercher et de consulter
des documents, et d'exploiter les liens hypertextuels qu'ils comportent.

Cours d'Informatique -- Glossaire
Octet :
ensemble ordonné de huit éléments binaires traités comme un tout. Un octet est souvent utilisé pour
représenter un caractère alphanumérique. Lorsqu'une grandeur est exprimée en multiples de l'octet, les
symboles Ko, Mo et Go représentent respectivement le kilooctet, le mégaoctet et le gigaoctet. Dans ce
cas, et contrairement à la norme, on considère généralement que le kilooctet est égal à 2 exp. 10 = 1 024
octets et non 1000 et le mégaoctet à 2 exp. 20 et non 1 000 000.
Serveur :
système informatique destiné à fournir des services à des utilisateurs connectés et, par extension,
organisme qui exploite un tel système
Toile d'araignée mondiale :
ou, ellipt., toile mondiale, toile. Dans l'internet, système, réparti géographiquement et structurellement,
de publication et de consultation de documents faisant appel aux techniques de l'hypertexte Équivalent
étranger : World Wide Web.
Prev Up Next

Cours d'Informatique -- Architecture d'un ordinateur
Up
Remonter : 2.3 L'ordinateur
Architecture d'un ordinateur

Un ordinateur comporte :
● Une unité centrale. C'est le "coeur" de l'ordinateur qui est actif en permanence (dès que l'ordinateur
est allumé). L'unité centrale est en charge de tous les traitements d'informations, et doit donc pour
cela disposer des programmes et des informations elles-mêmes. L'unité centrale (sur un ordinateur
personnel, c'est la "carte mère") comporte :
❍ Une unité centrale de traitement (CPU en anglais), ou processeur (que l'on appelle
micro-processeur, s'il est miniaturisé sur un seul composant comme dans les ordinateurs
personnels). La vitesse du processeur est souvent exprimée par sa "fréquence d'horloge" (par
exemple 500 MHz), qui caractérise la période (l'inverse, dans cet exemple 2 nano secondes)
nécessaire au fonctionnement de ses transistors. Cette mesure n'est significative que pour
comparer 2 processeurs identiques, car le nombre de périodes nécessaires à l'exécution d'une
instruction varie d'un processeur à un autre. Une mesure plus significative est le MIPS
(million d'instructions par seconde). Le processeur comporte lui-même 2 parties
principales :
■ L'unité de calcul comporte des dispositifs électroniques capables d'effectuer des
opérations logiques et arithmétiques sur les codes binaires
■ L'unité de commande est chargée de provoquer dans l'unité de calcul les opérations
prévues par le programme. Elle contrôle aussi l'ensemble des autres dispositifs de
l'ordinateur.
❍ La mémoire centrale : c'est là que sont mémorisés les informations et les programmes qui
les traitent, tout au long de l'exécution. Cette mémoire est aussi appelée mémoire vive (ou
RAM en anglais); elle est volatile, c'est-à-dire qu'elle perd ses informations dès qu'elle n'est
plus alimentée en courant. De sa capacité dépend la capacité de l'ordinateur à exécuter
efficacement de "gros programmes" sur des volumes de données importants, ou
éventuellement à exécuter plusieurs programmes "en même temps" (c'est le cas quand sur un
ordinateur personnel, on exécute plusieurs applications simultanément). La capacité de la
mémoire centrale varie couramment de quelques Méga-Octets à quelques Giga-octets.
Chaque emplacement de la mémoire est numéroté par une "adresse". Cette adresse est un
entier positif, indispensable pour retrouver l'endroit en mémoire où est mémorisée une
information. La mémoire centrale contient aussi toujours au moins un petit peu de "mémoire
morte" (ROM pour Read Only Memory), pour contenir le premier programme qui s'exécute
au démarrage. Dans le cas des ordinateurs embarqués, l'ensemble des programmes peut être
enregistré en ROM (ils ne sont alors plus modifiables).
● Une ou plusieurs unités de stockage (mémorisation) permanent des informations. De nombreuses
technologies sont disponibles. Elles se distinguent par leur capacité, leur temps d'accès, la
possibilité de lire mais aussi d'écrire des informations et leur fiabilité.

Cours d'Informatique -- Architecture d'un ordinateur
L'incoutournable disque dur a une grande capacité (plusieurs Go) et un temps d'accès très
❍
court. Indispensable pour conserver données et programmes. Doit cependant être sauvegardé
périodiquement.
❍ L'indémodable (?) disquette est de faible capacité (1,44 Mo), et a un temps d'accès long. En
passe d'être remplacée par des disquettes de plus grande capacité ou l'un des dispositifs
suivants.
❍ Les disques optiques numériques (ré-inscriptibles ou non : on parle alors de CD-ROM)
❍ Divers dispositifs de grande capacité, destinés à la sauvegarde périodique de toutes les

informations contenues sur un disque dur (lecteur ZIP, bandes ou disques)
● Une ou plusieurs unités de communication
❍ En entrée, avec l'utilisateur : clavier, souris, lecteur de cartes, crayon optique, scanner ...
❍ En sortie, vers l'utilisateur : écran, imprimante, table traçante ...
❍ Avec d'autres ordinateurs : modem (pour se raccorder via une liaison téléphonique), carte
réseau éthernet (pour se raccorder à un réseau local d'ordinateurs) ....
Up

Cours d'Informatique -- 8.2 La tour de Babel
Prev Up Next
Précédent : 8.1 Domaines d'application de l'informatique
Remonter : 8 Pour aller plus loin
Suivant : 8.3 Théories fondamentales
8.2 La tour de Babel

Un panorama des langages de programmation peut difficilement être exhaustif, tant ces langages sont
nombreux - plusieurs centaines en ne comptant que les langages d'usage courant.
Les causes de cette multiplication des langages sont de différentes natures :
● raisons historiques : les concepts ont évolués très rapidement pendant les 50 ans d'histoire de
l'informatique. Beaucoup de progrès ont été effectués entre les langages précurseurs (assembleur,
FORTRAN, COBOL, LISP) et les langages actuels.
● raisons commerciales : certains langages ne diffèrent guère fondamentalement, que par leur
"marque" de fabrique. A noter qu'il peut être risqué pour un client d'utiliser un langage "privé", car
les programmes qu'il développe ne sont alors utilisables que tant que le fournisseur du langage
maintient le langage à son catalogue.
● raisons scientifiques : un langage repose toujours sur un certain "mode d'expression" des
programmes. Il représente aussi un compromis entre la facilité d'expression pour le programmeur,
et la possibilité de faire exécuter efficacement les programmes. Différents compromis sont
possibles : un choix particulier dépend du domaine d'application visé et des performances requises.
● raisons techniques : la plupart des langages, même parmi les langages généraux, ciblent en fait un
ou plusieurs domaines d'applications particuliers. Les langages diffèrent alors par la manière de
programmer la communication entre l'ordinateur et l'utilisateur, et par les opérations particulières
destinées à ce (ou ces) domaine(s) d'application.
● raisons subjectives : la facilité d'expression est une notion subjective qui dépend du programmeur.
Le langage qu'il parle le mieux, lui semble toujours être celui où la "facilité d'expression" est la
plus grande.
En s'intéressant d'abord aux raisons scientifiques et techniques de la multiplication des langages, on peut
donner la classification suivante des langages utilisés actuellement, en citant quelques-uns des langages
les plus représentatifs de leurs classes. Certains langages appartiennent à plusieurs familles.
On distingue les langages selon le mode d'expression utilisé et le domaine d'application visé :
● Les langages impératifs permettent de décrire une séquence d'instructions à exécuter pour
calculer un résultat. Ce sont les plus courants. Parmi ceux-ci on peut distinguer :
❍ des langages destinés aux applications de gestion dont COBOL,
❍ des langages dédiés aux applications de calcul scientifique dont FORTRAN,
❍ des langages d'usage général dont Pascal, C, ADA ...
❍ des langages pour applications interactives dont JavaScript (JavaScript est un langage
impératif d'usage général avec des facilités pour la programmation d'applications

Cours d'Informatique -- 8.2 La tour de Babel
interactives sur internet)

Démonstration de quelques possibilités de JavaScript
● Les langages à objet privilégient l'expression de la structure d'un programme complexe, par
juxtaposition d'objets - un "objet" pouvant contenir des données et des morceaux de programme.
Parmi les langages à objet, se trouvent Smalltalk, C++, Java [Bro99] ainsi que de nombreuses
variantes avec objets (++) d'autres langages de programmation. Ces langages rencontrent un
succès croissant dans l'écriture de programmes très complexes.
● Les langages fonctionnels permettent de décrire un résultat, en fonction des données, sans avoir à
préciser l'ordre dans lequel doivent être effectués les instructions. Par ordre historique d'apparition,
citons les langages lisp, ML, Scheme, CAML [WL99], Haskell. Ces langages permettent une plus
grande simplicité d'expression que les langages impératifs, ceci au prix d'une traduction plus
difficile (pour l'ordinateur).
● Les langages de programmation logique permettent de décrire le (ou les) résultat(s) recherché(s)
en écrivant la relation qui le lie avec les données du problème. Ces langages, dont le premier et le
plus connu des représentants est PROLOG, ont permis d'exprimer et de résoudre des problèmes
difficiles d'accès pour d'autres formes de programmation. C'est le cas de problèmes d'optimisation
s'exprimant plus simplement par les contraintes que doit respecter la solution que par la méthode
pour y parvenir.
● D'autres types de langages existent avec des modes d'expression particuliers pour des domaines
d'application particuliers :
❍ les langages relationnels (pour les bases de données),
❍ les langages réactifs (pour les systèmes embarqués),
❍ les langages de description de circuits (pour le "hardware"),
❍ les langages de spécification (dont Z, B),
Cette classification ne doit pas être interprétée de manière rigide. Les langages y sont classés par ce qui
les caractérise le mieux. Cependant de nombreux langages se situent dans plusieurs catégories. Par
exemple, la variante la plus récente du langage ML (Objective Caml) est à la fois fonctionnel, impératif
et à objets.
La multitude des langages ne doit pas non plus effrayer le programmeur débutant. Les concepts utilisés,
s'ils peuvent être différents d'une classe de langages à une autre, sont les mêmes pour une classe de
langages donnée. Il suffit donc au programmeur de maîtriser un langage de chaque classe pour être
capable très rapidement (en quelques jours, le temps de lire le manuel) de s'adapter à n'importe quel
langage.
Prev Up Next

Cours d'Informatique -- Exemple d'algorithme
Up
Remonter : 2.4 Algorithmes, programmes et langages
Exemple d'algorithme
L'algorithme suivant, écrit de façon informelle, décrit une version simplifiée du calcul des impôts dus par un contribuable :
debut
demander a l'utilisateur son revenu annuel
memoriser sa reponse sous le nom: revenu
demander a l'utilisateur son nombre de part
memoriser sa reponse sous le nom: nbparts
SI revenu/nbparts < 25460
ALORS afficher : Vous n'avez pas d'impots a payer
SINON afficher : Le montant de votre impot est: (revenu*0,25)-(nbparts*5260)
fin
L'art et la manière d'écrire des algorithmes seront précisés progressivement dans les chapitres suivants. On verra en
particulier :
● comment programmer la communication avec l'utilisateur,
● comment manipuler des informations de différentes natures,

● comment programmer des calculs.
● comment programmer des traitements conditionnels.
Traduit dans un langage particulier, cet algorithme peut ensuite donner, le programme suivant en langage Pascal :
program impot;
var revenu, nbparts :real;
begin
writeln('Donner votre revenu annuel');
readln (revenu);
writeln('Donner votre nombre de parts');
readln (nbparts);
if (revenu/nbparts) < 25460
then writeln('Vous n avez pas d impots a payer')
else writeln('Le montant de votre impot est:',(revenu*0.25)-(nbparts*5260))
end.
ou celui-ci en langage JavaScript :
function impot ()
{ revenu=prompt('Donner votre revenu annuel ', 0);
nbparts=prompt('Donner votre nombre de parts ', 1);
if ((revenu/nbparts) < 25460)
{alert('Vous n avez pas d impots a payer')}
else {alert('Le montant de votre impot est:'+((revenu*0.25)-(nbparts*5260)))}}
Pour executer ce programme JavaScript
Noter les éléments de "ponctuation" (; , { } .), présents dans ces programmes en Pascal ou en Java. Ceci fait partie des règles
à respecter pour écrire des programmes corrects, et permet au compilateur de repérer les différentes instructions du
programme, pour pouvoir les traduire automatiquement.

Cours d'Informatique -- Exemple d'algorithme
Cette contrainte ne s'applique pas aux algorithmes dont l'écriture plus libre, doit permettre à la fois la compréhension des
programmeurs et la traduction facile vers n'importe quel langage de programmation.
Up

Cours d'Informatique -- 3.1 Communication homme-machine
Up Next
Remonter : 3 Communiquer de l'information
Suivant : 3.2 Communication entre ordinateurs : les réseaux
3.1 Communication homme-machine

La communication entre l'utilisateur et la machine s'effectue essentiellement grâce aux unités de
communication suivantes : écran, clavier, souris.
C'est le "système d'exploitation", qui est responsable du bon fonctionnement de la communication entre
l'utilisateur et la machine. Les modalités pratiques de communication varient donc d'un système à un
autre.
Système d'exploitation : Ensemble de programmes chargés de mettre les ressources matérielles de
l'ordinateur (unités de calcul, mémorisation et communication) à la disposition d'un utilisateur, ou de les
partager entre plusieurs utilisateurs.
Ce sont des programmes du système d'exploitation qui s'exécutent au démarrage d'un ordinateur, et qui
alors initient la communication avec l'utilisateur.
Celle-ci peut se dérouler dans l'un des modes suivants :
● en mode commande (texte) : c'est le mode de dialogue disponible en cas d'utilisation d'un terminal
alphanumérique ou dans une "fenêtre de commandes". L'utilisateur tape au clavier des
commandes, dont il peut voir s'afficher les résultats à l'écran. On peut alors constater, très
rapidement, le caractère stéréotypé du dialogue qui s'instaure : en cas de saisie d'une commande
non prévue dans le "langage de commande", l'utilisateur obtient du système, un message (souvent
en anglais) du type "command not found".
● en mode interactif (graphique) : le système montre à l'utilisateur, à l'écran, un point de vue sur son
ordinateur. Par exemple, il peut y avoir des icônes représentant une disquette, une imprimante
...des menus permettant d'accéder aux fonctions proposées par le système ou aux programmes
d'application (traitement de texte, tableur, compilateur ...). La communication s'effectue alors en
"cliquant" sur les ressources concernées, en choisissant dans des menus ...
Dans tous les cas, la communication entre l'ordinateur et l'utilisateur est nécessairement stéréotypée. Les
réponses de l'ordinateur peuvent être difficiles à interpréter. Pour celà, il faut parfois tenter de "se mettre
à la place de l'ordinateur", ou plutôt du programmeur qui l'a programmé. Il faut se convaincre que c'est
toujours l'ordinateur qui est programmé pour attendre telle ou telle demande de l'utilisateur, à un moment
donné de son exécution, même si l'utilisateur peut parfois avoir l'illusion d'être à l'initiative de la
communication.
Up Next

Cours d'Informatique -- 3.2 Communication entre ordinateurs : les réseaux
Prev Up Next
Précédent : 3.1 Communication homme-machine
Suivant : 3.3 Programmer la communication
3.2 Communication entre ordinateurs : les réseaux

Le "protocole" suivant, illustre le type de communication possible entre deux ordinateurs. Un premier ordinateur est
programmé pour être un automate d'appels téléphoniques diffusant un message publicitaire. Le second est aussi branché
sur le réseau téléphonique et simule un répondeur téléphonique.
Leurs algorithmes sont les suivants (en version simplifiée) :
debut automate appel

decrocher
composer le numero
attendre au plus pendant 10 sonneries que le recepteur decroche
SI il a decroche
ALORS diffuser le message ``Bonjour, la société Duschmoll vous propose ...''
raccrocher
fin
debut repondeur
attendre appel
attendre 4 sonneries
decrocher
diffuser l'annonce ``Je suis absent, mais vous pouvez me laisser un
message, parlez apres le bip''
emettre un bip
enregistrer ce que dit l'interlocuteur jusqu'a ce qu'il racroche
fin
En cas d'appel du second par le premier, chaque ordinateur exécute son programme, presque sans se soucier de l'autre (en
entendant ce qu'il veut entendre). Le répondeur enregistre alors la fin du message publicitaire !
C'est ainsi que fonctionnent tous les protocoles de communication entre ordinateurs.
Protocole de communication : ensemble de règles régissant les modalités d'établissement de la communication,
d'échange d'informations, et de rupture de la communication entre deux (ou plusieurs) ordinateurs. Un protocole est mis en
oeuvre par (au moins) un programme exécuté sur chacun des ordinateurs communiquant.
La communication entre ordinateurs requiert donc :
● un (ou plusieurs) dispositif(s) matériel reliant les ordinateurs
❍ une ligne téléphonique classique (réseau dit "commuté") ou cellulaire (téléphone portable)
❍ une liaison spécialisée : fibre optique, cable, liaison hertzienne ou par satellite
❍ toute combinaison des lignes précédentes
● des programmes respectant un protocole de communication. Parmi les très nombreux protocoles qui ont été
normalisés, les suivants s'adressent à l'utilisateur et sont d'un usage courant :
❍ internet (IP: Internet Protocol)
❍ transfert de fichiers (FTP: File Tranfer Protocol)

Cours d'Informatique -- 3.2 Communication entre ordinateurs : les réseaux
❍ courrier électronique (e-mail)

❍ connexion à distance (Telnet)
D'autres protocoles régissent les modalités de gestion technique de la communication (pour réémettre en cas de
problème, acheminer par différents chemins ...) et sont alors "cachés" à l'utilisateur.
● Internet
● Le courrier électronique
● Connexion à distance et transfert de fichiers

Prev Up Next

Cours d'Informatique -- 3.3 Programmer la communication
Prev Up Next
Précédent : 3.2 Communication entre ordinateurs : les réseaux
Suivant : Exercices
3.3 Programmer la communication

Pour programmer la communication d'un ordinateur avec son utilisateur (ou avec un autre ordinateur), il faut prévoir les
échanges d'information.
On se place pour cela, dans le point de vue de l'ordinateur (ce qui peut être troublant pour le programmeur qui est aussi
souvent le premier utilisateur de son programme).
Les deux instructions de base de la communication, que l'on utilisera dans l'écriture des algorithmes, sont :
● la lecture d'informations à fournir par l'utilisateur (le plus souvent au clavier) et leur mémorisation sous un nom
choisi par l'utilisateur, que l'on notera : lire(nom). A noter que pour l'utilisateur, il faudra alors écrire les
informations à lire par l'ordinateur.
● l'écriture d'informations (le plus souvent à l'écran) à destination de l'utilisateur (qui pourra alors les lire), que l'on
notera : ecrire(...). L'information (ou les informations) à écrire peuvent être des messages "texto", placés
alors entre guillemets, ou des noms faisant référence à des informations mémorisées ou calculées.
L'algorithme de calcul des impôts peut alors être réécrit plus précisément ainsi :
debut
ecrire ('Donner votre revenu annuel')
lire (revenu)
ecrire ('Donner votre nombre de parts')
lire (nbparts)
SI revenu/nbparts < 25460
ALORS ecrire('Vous n'avez pas d impots a payer')
SINON ecrire('Le montant de votre impot est:',(revenu*0,25)-(nbparts*5260)
fin
Noter que dans la dernière instruction d'écriture, la première partie est un message à écrire "texto", alors que la seconde
est à calculer avant affichage.
Les traductions présentées précédemment de cet exemple d'algorithme s'éclairent maintenant par les schémas de
traduction suivant :
En langage Pascal :
● lire se traduit par : readln
● ecrire se traduit par : writeln
En langage JavaScript :
● lire peut se traduire par : prompt, instruction qui permet de plus d'écrire un message demandant la donnée à
lire, économisant ainsi l'écriture précédant habituellement une lecture
● ecrire peut se traduire par : alert

Prev Up Next

Prev Up Next
Précédent : 3.3 Programmer la communication
Suivant : Corrigés et indications
Exercices
Exercice 3.1 : Utilisation d'un moteur de recherches
La "navigation" sur Internet comporte bien des écueils ! Pour s'en convaincre :
● choisir un domaine de connaissances (bien maîtrisé de préférence - par exemple la géographie
physique de la Sibérie),
● se poser une question précise (quel est le nom du fleuve qui arrose la ville de ...?), et la caractériser
par plusieurs mots clés,
● effectuer une recherche sur un moteur, par exemple : http://www.yahoo.fr, en saisissant les mots
clés choisis,
● analyser la pertinence des informations trouvées par rapport à la question posée.
Exercice 3.2 : Conversion: Francs, Euros

Ecrire un algorithme qui :
● demande à l'utilisateur de saisir une somme en Francs
● mémorise la valeur sous le nom MontantEnFrancs
● affiche le montant équivalent en Euros, sachant que : 1 Euro = 6,55957 Francs
Traduire cet algorithme en langage JavaScript.

Exercice 3.3 : Lecture/Ecriture en Pascal
Tester les 2 programmes Pascal suivants, pour en comprendre les différences:
{ Du bon usage des apostrophes, version 1}

program apos;
var personne : string;
begin
writeln('Bonjour, comment vous appellez vous ?');
readln (personne);
write ('Mon nom est');
writeln (' personne ')
end.
Voici le second, à mettre dans un autre fichier:

{ Du bon usage des apostrophes, version 2 }

program trophe;
var personne : string;
begin
writeln('Bonjour, comment vous appellez vous ?');
readln (personne);
write ('Votre nom est ');
writeln ( personne )
end.
Prev Up Next

Cours d'Informatique -- Corrigés et indications
Prev Up
Précédent : Exercices
Corrigés et indications
Exercice 3.2
L'algorithme de conversion de Francs en Euros, doit essentiellement prévoir les communications avec
l'utilisateur :
debut
ecrire ('Donner un montant en Francs ')
lire (MontantEnFrancs)
ecrire ('La valeur en Euros est : ', MontantEnFrancs / 6.55957)
fin
La traduction en langage JavaScript est directe, en utilisant les instructions de lecture et écriture de JavaScript :
function euro ()
{ MontantEnFrancs=prompt('Donner un montant en Francs ', 0);
alert('La valeur en Euros est : ' + MontantEnFrancs / 6.55957)
}
Exercice 3.3
La différence entre les 2 programmes, est l'utilisation des apostrophes. Si l'utilisateur répond : Dupond, à
chacun de ces programmes.
● Le premier répond alors : Mon nom est personne
car le programme contient une instruction d'écriture de : ' personne ', en toutes lettres.
● Le second programme répond : Votre nom est dupont
car l'instruction d'écriture, s'applique à l'information : personne, mémorisée quand l'utilisateur a
répondu : Dupond
Prev Up

Cours d'Informatique -- Internet
Up Next
Remonter : 3.2 Communication entre ordinateurs : les réseaux
Suivant : Le courrier électronique
Internet
Issu de différents réseaux connectant les universités, les organismes gouvernementaux et militaires
américains, internet connecte actuellement plusieurs millions d'ordinateurs dans le monde.
La structuration du réseau se fait par l'usage d'adresses normalisées (dites adresses IP) de la forme:
nom_machine.nom_sous_domaine. ... .nom_domaine. Les noms de domaines sont
(ethnocentrisme américain oblige) edu, gov, mil, com pour les domaines américains pré-cités plus un
domaine par pays (fr pour la France ...univ-nantes.fr pour l'Université de Nantes).
Le principe de fonctionnement de la "toile" est le suivant :
● Sur chaque machine connectée, des informations peuvent être stockées et rendues accessibles au
reste du monde,
● Chaque utilisateur consulte ce qu'il veut à l'aide l'un logiciel de navigation. Il peut spécifier le
"site" à consulter en indiquant son adresse et le protocole employé (http: Hyper Text Transfer
Protocol), et suivre ensuite les liens hypertexte sans se préoccuper de la machine ou réside
l'information référencée. Pour l'aider dans ses recherches il peut consulter un "moteur de
recherche".
On peut par exemple consulter les sites suivants:
● celui de l'Université de Nantes : http://www.univ-nantes.fr
● celui du Ministère de l'Education Nationale : http://www.education.gouv.fr

● ou bien d'autres ...
Le principe de libre-diffusion, qui a conduit au succès du réseau Internet, en permettant de "tout
communiquer", ne le met cependant pas à l'abri d'un certain nombre de dangers: hégémonie commerciale
de certains acteurs économiques, hégémonie culturelle par la prédominance d'une langue sur les autres
(chercher laquelle !), diffusion d'informations erronées voire diffamatoires, difficulté à trouver
l'information recherchée ...et à savoir quel degré de confiance accorder à l'information obtenue.
Up Next

Cours d'Informatique -- Le courrier électronique
Prev Up Next
Précédent : Internet
Suivant : Connexion à distance et transfert de fichiers
Le courrier électronique
Le courrier électronique partage avec internet la norme de nommage des ordinateurs mais il obéit à une
autre logique : il s'agit d'une communication de personne à personne, à condition que les interlocuteurs
disposent chacun d'une "adresse électronique".
Par exemple, l'auteur de ce cours peut être contacté à l'adresse suivante :
● Christophe.Mauras@info.univ-nantes.fr
Pour envoyer et recevoir des courriers électroniques, il suffit de disposer d'un ordinateur connecté au
réseau, et d'un programme spécifique respectant le protocole concerné.
Prev Up Next

Cours d'Informatique -- Connexion à distance et transfert de fichiers
Prev Up
Précédent : Le courrier électronique
Connexion à distance et transfert de fichiers

Ces deux services peuvent être utilisés aussi bien à l'intérieur d'un réseau local à une organisation
(entreprise, université, administration) qu'au niveau du réseau mondial.
Réseau local : ensemble d'ordinateurs regroupés géographiquement et partageant, grâce à une
connexion entre eux, différents services tels que : impression, stockage des données, utilisation d'un
même serveur de calcul ...
La connexion à distance (distance qui peut donc être plus ou moins grande) permet depuis un ordinateur,
d'exécuter des programmes sur un autre ordinateur, et d'obtenir les résultats sur le sien. Il s'agit d'une
communication bi-directionnelle, qui est généralement soumise à une autorisation d'accès.
Le protocole de transfert de fichier (FTP) permet de transférer des fichiers d'un ordinateur à un autre. Il
peut, selon les cas, être ou non soumis à une autorisation d'accès. C'est le propriétaire du fichier qui en
décide (s'il n'y a pas de contrôle d'accès, on parle de "transfert anonyme"). Internet est fondé sur ce genre
de tranfert, sans que l'utilisateur n'ait à s'en occuper: les fichiers contenant l'information demandée sont
tranférés avant d'être affichés.
Prev Up

Cours d'Informatique -- 4.1 Codages
Up Next
Remonter : 4 Représenter l'information
Suivant : 4.2 Programmer avec différents types d'informations
4.1 Codages
Les caractères
Pour coder les caractères avec un octet, le codage standard ASCII (American Standard Code for
Information Interchange), définit le codage de 128 caractères parmi les 256 codes disponibles. Ce codage
est donné dans le tableau ci-dessous, pour les caractères dont les codes sont compris entre 32 et 127. Les
codes de 0 à 31 sont utilisés pour coder des "caractères non imprimables" mais utiles tels que le "Retour
Chariot" (code 13) et d'autres caractères de commande.
Code Caractère Code Caractère Code Caractère Code Caractère
32 Space 33 ! 34 " 35 #
36 $ 37 % 38 & 39 '
40 ( 41 ) 42 * 43 +
44 , 45 - 46 . 47 /
48 0 49 1 50 2 51 3
52 4 53 5 54 6 55 7
56 8 57 9 58 : 59 ;
60 < 61 = 62 > 63 ?
64 @ 65 A 66 B 67 C
68 D 69 E 70 F 71 G
72 H 73 I 74 J 75 K
76 L 77 M 78 N 79 O
80 P 81 Q 82 R 83 S
84 T 85 U 86 V 87 W
88 X 89 Y 90 Z 91 [
92 \ 93 ] 94 ^ 95 _
96 ` 97 a 98 b 99 c
100 d 101 e 102 f 103 g
104 h 105 i 106 j 107 k
108 l 109 m 110 n 111 o
112 p 113 q 114 r 115 s
116 t 117 u 118 v 119 w

120 x 121 y 122 z 123 {

124 | 125 } 126 ~ 127 Del
Plusieurs normes de codage des caractères existent. Elles incluent la plupart les 128 premiers codes du
code ASCII, mais diffèrent dans leur usage des 128 codes restant disponibles. Parmi ces normes, la
norme dite : iso-latin-1 permet de représenter les caractères accentués présents dans les langues latines
dont le français.
D'autres codages (dits étendus car ils incluent aussi et étendent le code ASCII) sont propres à un
constructeur d'ordinateurs ou de systèmes d'exploitation, et sont alors à utiliser avec précaution, dès qu'il
s'agit de communiquer avec un autre ordinateur.
Les nombres entiers naturels
Les entiers positifs sont codés en binaire par leur représentation en base 2. Ecrire un nombre en base 2
consiste à le décomposer en une somme de puissances de 2.
Exemple : 213 = 1*27 + 1*26 + 0*25 + 1*24 + 0*23 + 1*22 + 0*21 + 1*20
= 1*128 + 1*64 + 0*32 + 1*16 + 0*8 + 1*4 + 0*2 + 1*1,
L'écriture en base 2 de 213 s'obtient alors en écrivant la suite des facteurs (0 ou 1), ce qui donne le code :
11010101
Les codes de 00000000 à 11111111 permettent alors de représenter les 256 entiers naturels de 0 à
255. Plus généralement, en utilisant n chiffres binaires (au lieu de 8 dans cet exemple), on peut coder les
entiers naturels de 0 à 2n - 1. Dans la pratique, les entiers sont la plupart du temps représentés avec 16, 32
ou 64 bits (respectivement 2, 4 ou 8 octets).
Les nombres entiers relatifs
Les nombres entiers relatifs sont codés par une adaptation du codage binaire, appelée "complément à 2",
où l'on réserve la moitié des codes pour les nombres négatifs. La règle de codage est alors la
suivante (pour un code sur n bits):
● Si le nombre x à coder est positif, on prend son code en base 2,
● Si le nombre x est négatif, on prend le code en base 2 de: x + 2n

Ce codage permet de représenter les nombres compris entre - 2n-1 et 2n-1 - 1. Le tableau suivant illustre le
codage en complément à 2 sur 8 bits :
Entier relatif -128 ... -1 0 1 ... 127
Code 10000000 ... 11111111 00000000 00000001 ... 01111111
Entier naturel 128 ... 255 0 1 ... 127
Les nombres réels
Parmi les représentations possibles des (de certains) nombres réels, la plus courante consiste à utiliser un

codage en base 2 "à virgule flottante".

On peut utiliser la virgule, dans un code binaire, avec la signification suivante : les digits (0 ou 1) après la
virgule ont les valeurs : 1/2, 1/4,1/8, ...1/2i.
Par exemple, le nombre 13,578125 peut s'écrire en "base 2 à virgule" : 1101,100101 En effet:
13,578125 = 1*23 + 1*22 + 0*21 + 1*20 + 1*2-1 + 0*2-2 + 0*2-3 + 1*2-4 + 0*2-5 + 1*2-6
La représentation en base 2 à virgule flottante, consiste à ajouter un exposant permettant de représenter à
la fois des nombres très grands ou très petits. On normalise les codages de telle sorte qu'ils s'écrivent sous
la forme 1,..., et on ajoute l'exposant, lui même codé en base 2. Pour pouvoir représenter des nombres
positifs et négatifs, on ajoute aussi un "bit de signe" à la mantisse (0 pour positif, 1 pour négatif).
Par exemple, le nombre 13,578125 peut être codé en base 2 à virgule flottante par la mantisse :
1,101100101,le signe :0 et l'exposant : 0011 (codant l'entier 3). En effet: 13,578125 = (1*20 + 1*2-1
+ 0*2-2 + 1*2-3 + 1*2-4 + 0*2-5 + 0*2-6 + 1*2-7 + 0*2-8 + 1*2-9 ) * 23
Le nombre d'octets réservés pour la mantisse détermine la précision du codage des nombres réels. Le
nombre d'octets réservés pour l'exposant (qui est un entier relatif) détermine la gamme des ordres de
grandeur représentables (du plus petit au plus grand).
Deux standards sont utilisés couramment (IEEE Standard for Binary Floating Point Arithmetic,
ANSI/IEEE Std 754-1985) : un codage sur 4 octets (23 bits de mantisse, 1 bit de signe, 8 bits
d'exposant), et un codage dit "à double précision" sur 8 octets (52 bits de mantisse, 1 bit de signe, 11 bits
d'exposant).
Il faut noter que le codage d'un nombre réel en base 2 à virgule flottante est rarement exact (seulement
s'il est un multiple de 2-i). Par exemple, le code de 1,4 serait :
1.0110011001100110011001100110011001100110011001100110... Si le code est
restreint à 23 bits, soit :1.01100110011001100110011, la valeur réelle représentée est :
1.39999998 ce qui est bien une approximation de 1,4 à 2-23 près.
Le programmeur n'a, fort heureusement, jamais à manipuler les codes des nombres qu'il manipule.
Cependant il lui est indispensable de savoir que le calcul en "nombres réels" est presque toujours un
calcul approché, pour en tenir compte dans l'interprétation de ses résultats.
Et les informations plus complexes ?
Les paragraphes précédents montrent différents codages pour des informations élémentaires (nombres,
caractères), utilisant un ou plusieurs (2,4,8) octets. Pour des informations plus complexes (un texte, une
image, ...) on utilisera des formats définissant comment "arranger" bout à bout des informations
élémentaires.
Up Next

Cours d'Informatique -- 4.2 Programmer avec différents types d'informations
Prev Up Next
Précédent : 4.1 Codages
Suivant : 4.3 Fichiers et formats
4.2 Programmer avec différents types

d'informations
Un programme définit l'enchaînement de communications, entre la machine et l'utilisateur, et de
traitements. Des informations sont mémorisées pour ensuite être traitées. La façon dont elles sont
mémorisées (avec des 0 et des 1, donc en utilisant un certain codage) doit alors être connue du
programme, pour que les traitements puissent tenir compte de ce codage (pour qu'elles soient relues et
comprises, comme elles ont été écrites).
Un programme doit donc contenir, de façon implicite ou explicite, la définition des codages de toutes les
informations mémorisées. C'est ce qui est fait grâce à la notion de "types".
Type : Ensemble de valeurs, caractérisé par un certain codage, et par les opérations qu'il est possible
d'effectuer sur les informations de cet ensemble.
Dans l'écriture d'algorithmes, on utilisera les types élémentaires suivants, que l'on peut retrouver dans la
grande majorité des langages de programmation.
● Type entier : ensemble des entiers relatifs, appartenant à un intervalle [-Max .. Max[, codés en
complément à deux. On peut effectuer sur les entiers, des opérations arithmétiques : +, -, *, /
(division euclidienne), et des comparaisons : <= , <, >, >= , =, != (donnant un résultat vrai ou
faux).
● Type booléen (ou logique) : ensemble ne contenant que les 2 valeurs : vrai, faux, codées
respectivement par 1 et 0. C'est le type du résultat des comparaisons. Les opérations disponibles
sont : et, ou, non.
● Type réel : ensemble des nombres réels représentables (varie selon la machine et le langage de
programmation utilisés). En plus des opérations arithmétiques, on peut effectuer sur les réels des
opérations trigonométriques ou logarithmiques.
● Type caractère : l'ensemble des caractères représentables pour un codage particulier. On les note
entre apostrophes (par exemple : 'a') pour les distinguer des caractères servant à écrire le texte d'un
programme. Les seules opérations disponibles sur les caractères sont les comparaisons, sachant
que l'ordre des caractères est celui de leurs codes. On a ainsi :
'A' < 'B' < ... < 'Z' < 'a' < 'b' ... < 'z', ce qui correspond à l'ordre
alphabétique, si l'on prend garde de ne pas comparer des majuscules avec des minuscules.
● Type chaîne de caractères : Une chaîne de caractères est une suite (finie) de caractères, que l'on
note aussi entre apostrophes, par exemple : 'Le resultat est 12'. Elle sont principalement utilisées
dans les programmes pour communiquer avec l'utilisateur (lire ou écrire). Sont disponibles,les
opérations de comparaison (avec le même sens que pour les caractères) et une opération

particulière : la concaténation, qui permet de mettre bout à bout 2 chaînes de caractères, pour n'en
former qu'une seule.
Dans un algorithme, ou un programme, pour que la mémorisation d'information soit possible, chaque
information doit avoir un type. Chaque information doit aussi avoir un nom - tout simplement pour
savoir comment la nommer quand un programme doit utiliser plus tard, une information qu'il a
mémorisée auparavant. Ceci a d'ailleurs déjà été utilisé dans les premiers exemples d'algorithmes et de
programmes, par une formule du genre : memoriser sa reponse sous le nom: revenu
Variable : on appelle variable, l'unité élémentaire de mémorisation de l'information. Une variable est
caractérisée par :
● son nom, pour la retrouver,
● son type, qui définit l'ensemble des valeurs pouvant être mémorisées sous son nom,
● sa valeur, qui peut changer au cours de l'exécution du programme, d'où le nom de "variable".
Avant de préciser dans un algorithme les traitements que l'on veut faire effectuer à un ordinateur, on fait
le bilan des informations à mémoriser. Ceci est fait dans les "déclarations".
Déclarations : un algorithme commence toujours par une partie dite de "déclarations", où sont
énoncées la liste des variables utilisées, et pour chacune leur type et leur utilité.
Exemple : Pour l'algorithme de calcul des impôts les déclarations doivent être les suivantes:
identificateur type rôle
revenu réel donnée du problème : le revenu annuel
nbparts réel donnée du problème : le nombre de parts
Variables et Types en Pascal et en JavaScript
Pour traduire un algorithme, les correspondances des types sont donnés dans le tableau suivant :
Dans un algorithme En langage Pascal En langage JavaScript
Entier integer Number
Booléen boolean Boolean
Réel real Number
Caractère char String
Chaîne de caractères string String
Les déclarations de variables doivent respecter une "syntaxe" précise, en pascal et en java.
Pour l'exemple précédent, les déclarations sont respectivement :

● en Pascal :

var revenu, nbparts :real;

● en JavaScript, il n'est pas nécessaire de donner les types des variables; ces types sont calculés
automatiquement à l'exécution du programme :
var revenu ;
var nbparts ;
Prev Up Next

Cours d'Informatique -- 4.3 Fichiers et formats
Prev Up Next
Précédent : 4.2 Programmer avec différents types d'informations
Suivant : 4.4 Enjeux de société
4.3 Fichiers et formats

Au niveau "microscopique" - c'est à dire du point de vue du programmeur -, l'ordinateur manipule des
informations élémentaires (un entier, un réel, un caractère ...) par des programmes manipulant des
variables ayant chacune un nom et un type.
A un niveau "macroscopique" - celui de l'utilisateur d'un progiciel, par exemple - l'ordinateur manipule
des informations beaucoup plus complexes par des logiciels manipulant des fichiers ayant chacun un
nom et un format.
L'analogie mérite d'être citée, car ces situations analogues, induisent des solutions analogues.
Fichier : on appelle fichier, un ensemble d'informations, éventuellement complexe, destiné à être
mémorisé de façon permanente dans la mémoire d'un ordinateur. Un fichier est caractérisé par :
● son nom, qui permet de le retrouver,
● son format (l'analogue du type,pour une variable) qui définit la façon dont les informations sont
rangées,
● son contenu, qui est une suite d'informations élémentaires rangées en respectant le format.
Un fichier peut servir à mémoriser un texte (ce document de cours est contenu dans un fichier dont le
nom est : cours.tex), une image, mais aussi un programme ...
C'est le système d'expoitation d'un ordinateur qui est responsable de fournir à l'utilisateur le moyen de
gérer ses fichiers : les créer, les retrouver, les modifier, les imprimer s'ils sont imprimables, les visualiser
s'ils sont visualisables, les exécuter s'ils sont exécutables ...
La notion de format est fondamentale, car en définissant la règle selon laquelle les informations sont
rangées, elle permet à quiconque connaît la règle de "comprendre" ces informations. Les formats ont
avantage à être normalisés, pour permettre à un utilisateur de communiquer un fichier à un autre
utilisateur, et à ce dernier de comprendre le fichier qu'il reçoit. Le format d'un fichier définit aussi
implicitement les opérations qu'il est possible de faire avec ce fichier - l'imprimer, le visualiser,
l'exécuter...
De nombreux systèmes d'exploitation incitent, ou obligent, l'utilisateur à nommer les fichiers en leur
donnant un nom faisant allusion au format selon lequel ils sont codés, par un système d'extension : par
exemple monprogramme.pas pour un programme en langage Pascal, maphoto.jpg pour une
image codée selon le format JPEG ...
Faire un recensement exhaustif des formats de fichiers existants serait une tâche illusoire et titanesque,
tant ces formats sont nombreux, et leurs évolutions rapides. En effet, il existe nécessairement autant de

Cours d'Informatique -- 4.3 Fichiers et formats
formats que de sortes d'information manipulables par ordinateur. De plus de nombreux logiciels
définissent leurs propres formats, destinés à mémoriser les informations que ces logiciels permettent de
collecter - on parle alors de "format propriétaire". Un fichier créé selon un tel format, ne peut souvent
être visualisé ou modifié que par le logiciel qui a servi à le créer. Il est alors strictement déconseillé de
communiquer de tels fichiers sans s'assurer au préalable que le destinataire dispose du logiciel nécessaire.
En se restreignant à quelques formats standards ou normalisés ou dont la définition est "du domaine
public" (c'est-à-dire libre de droit d'utilisation ou "licence"), on peut citer les formats suivants, en les
classant par types d'informations représentées :
● Le format "texte" est le plus simple. Un fichier "texte" contient une suite de caractères codés selon
un des codages disponibles pour les caractères (ASCII ou extension, normalisée si possible).
● Les formats de "texte mis en page et imprimable" sont utilisés pour la PAO (Publication Assistée
par Ordinateur). Parmi les nombreux formats de cette catégorie, les formats PDF (Portable
Document Format) et PostScript sont les plus utilisables sur de nombreux types d'ordinateurs
différents et sont compris par la majorité des imprimantes.
● Les formats d'images sont très nombreux, ils se distinguent par leur capacité à "comprimer" les
images, c'est-à-dire à les représenter avec un minimum de perte d'information, dans un espace
mémoire minimal. Parmi les plus courants, on peut citer les formats : PICT, JPEG.
● Le format HTML (Hyper Text Markup Language) est le format normalisé pour les documents
hypertexte consultables par internet.
● Les formats MPEG (Moving Pictures Experts Groups) sont les formats normalisés par l'ISO
(International Standard Organisation) pour les images animées, le son et la vidéo.
Les formats de fichier "binaire exécutable" sont, quant à eux, par nature liés au type d'ordinateur et au
système d'exploitation, pour lesquels ils ont été compilés.
Prev Up Next

Cours d'Informatique -- 4.4 Enjeux de société
Prev Up Next
Précédent : 4.3 Fichiers et formats
Suivant : Exercices
4.4 Enjeux de société

Les fichiers, et plus généralement le phénomène d'informatisation de la société pose dans des termes
nouveaux, de nombreuses questions d'ordre éthique, social, économique ou juridique. Pour une approche
générale de ces problèmes, on peut consulter de nombreux ouvrages, dont un numéro récent de la revue
Manière de voir [MAd99], qui en présente une étude critique et prospective, ainsi que l'étude
"Technologies et société de l'information" publiée par le Secrétariat d'Etat à l'industrie [TSI99].
Concernant les fichiers, les aspects suivants ont été réglementés :

● La loi informatique et libertés réglemente en France l'usage de fichiers nominatifs. Son application
est contrôlée par la Commission Nationale de l'Informatique et des Libertés
● La diffusion de fichiers contenant des programmes est soumise au "droit du logiciel".
Loi informatique et libertés
Ce document provient du site Internet de la Commission Nationale de l'Informatique et des Libertés (CNIL) :
http://www.cnil.fr. Les droits de reproduction sont réservés et strictement limités
La loi du 6 janvier 1978 reconnaît essentiellement 7 droits aux personnes :

● le droit à l'information préalable : les fichiers ne doivent pas être créés à votre insu. Les personnes qui créent des
traitements ne doivent pas vous laisser dans l'ignorance de l'utilisation qu'ils vont faire de ces données. Dans un tel
cas, la loi "Informatique et libertés" est purement et simplement violée. Ne soyez pas passif, exigez cette
information.
● le droit de curiosité : pour pouvoir accéder aux données qui vous concernent, vous avez le droit de demander à tout
organisme s'il détient des informations sur vous.
● le droit d'accès direct : vous pouvez obtenir communication des informations qui vous concernent en les demandant
directement à l'organisme qui détient le fichier dans lequel vous figurez. C'est un droit fondamental qu'il ne faut pas
hésiter à exercer.
● le droit d'accès indirect : pour certaines données nominatives, la loi prévoit un intermédiaire entre vous et
l'organisme qui détient le traitement. Pour les données médicales, un médecin de votre choix, pour les données
figurant dans des traitements intéressant la sûreté de l'Etat, la défense et la sécurité publique, un commissaire de la
CNIL.
● le droit de rectification : si vous avez constaté des erreurs lorsque l'organisme qui détient le fichier vous a
communiqué les données vous concernant, vous pouvez les faire corriger. La loi va même plus loin puisqu'elle
oblige l'organisme à rectifier d'office et de lui-même les informations dès lors qu'il a connaissance de leur
inexactitude.
● le droit d'opposition : si vous avez des raisons légitimes pour ne pas figurer dans tel ou tel fichier, vous pouvez
vous opposer à votre fichage. La loi garantit un droit d'opposition que l'on peut exercer au moment de la collecte ou
plus tard, en demandant par exemple la radiation des données contenues dans les fichiers commerciaux. Bien sûr,
ce droit ne s'applique qu'aux fichiers qui n'ont pas été rendus obligatoires par une loi.
● le droit à l'oubli : l'informatique permet de conserver indéfiniement les données personnelles. La loi a donc prévu

Cours d'Informatique -- 4.4 Enjeux de société
un droit à l'oubli, afin que les personnes ne soient pas marquées à vie par tel ou tel événement.
Droit du logiciel
Le droit applicable à la production et à la diffusion de logiciels est très variable d'un pays à l'autre, et
subit des évolutions rapides. Ce qui suit tente de décrire la situation à la date de publication de ce cours et
peut être périmé très rapidement.
Certains pays (comme les USA) admettent le dépôt de brevets sur les logiciels et pratiquent la technique
du "copyright" (protégeant surtout l'éditeur, moins l'auteur).
En France, le logiciel est protégé par le Code de la Propriété Intellectuelle, qui privilégie le "droit
d'auteur", en particulier par la loi du 3 juillet 1985. Celle-ci interdit pour le logiciel toute reproduction
autre que l'établissement d'une copie de sauvegarde. La réglementation sur les contrefaçons s'applique
au logiciel.
Chaque exemplaire d'un logiciel est une reproduction, qui ne confère à son propriétaire que le droit
d'utilisation, selon les termes d'une "licence".
Dans le cas particulier des logiciels distribués gratuitement - "graticiels" (en anglais : Freeware) - ou
presque - "partagiciels" (en anglais : Shareware), l'auteur peut donner l'autorisation de diffusion gratuite.
Les logiciels du "domaine public" (parce ce qu'ils datent de plus de 25 ans, ou que leur auteur a renoncé à
tous ses droits) sont libres de droit.
Concernant la sécurité des systèmes informatiques, les textes s'appliquant en France, sont :
● La loi n° 88-19 du 5 janvier 1988 relative à la fraude informatique,
● Les décrets n° 98-206 et 98-206 du 23 mars 1998 relatifs à la cryptologie.
D'autres textes sont annoncés à propos de la société de l'information : adaptation du droit de la preuve
aux nouvelles technologies et relatif à la signature électronique, protection de la vie privée et des données
personnelles, des droits d'auteurs, de la propriété industrielle, protection contre les contenus et
comportements illicites.
Prev Up Next

Prev Up Next
Précédent : 4.4 Enjeux de société
Exercices
Exercice 4.1 : Conversion d'un entier naturel en base 2
Ecrire un nombre en base 2 consiste à le décomposer en une somme de puissances de 2. Pour calculer les
éléments du code (0 ou 1) affectés à chaque puissance de 2, on suit la méthode suivante.
On divise le nombre par 2, le reste donne le nombre de fois 20. On divise le quotient obtenu par 2, le
reste donne le nombre de fois 21. On divise le quotient obtenu par 2, le reste donne le nombre de fois 22.
On continue de même, jusqu'à obtenir un quotient nul. Le code en base 2 est alors obtenu en mettant les
restes successifs dans le bon ordre.
Exemple :
213/2 = 106 reste 1 106/2 = 53 reste 0
53/2 = 26 reste 1 26/2 = 13 reste 0
13/2 = 6 reste 1 6/2 = 3 reste 0
3/2 = 1 reste 1 1/2 = 0 reste 1
Le code de 213 en base 2 est donc 11010101

Question : Convertir en base 2, l'entier 357.
Exercice 4.2 : Codages
Voici des informations, tels que l'on pourrait les voir à l'intérieur de la mémoire d'un ordinateur :
001111000010101000100011011000110110010101100011
011010010010000100101000011001010111001101110100
001010010010011001110101011011100011111100101011
011011010110010101110011011100110110000101100111
011001010010000100101101011100110111010101100010
011011000110100101101101011010010110111001100001
01101100001000110010101000111110
Quelle signification accorder aux informations enregistrées ? La réponse dépend du codage qui a été
employé pour les enregistrer.
Décoder le "message" ci-dessus en considérant successivement :

● que sont codés des entiers naturels sur 8 bits,

● que sont codés des entiers naturels sur 16 bits,
● que sont codés des caractères, selon le code ASCII.
On se limitera au début du "message".
Exercice 4.3 : A propos de la précision des réels
Exécuter le programme Pascal suivant et observer le résultat affiché :
program precision;
var x,y :real;
begin
x := 0.7;
y := 0.3;
writeln ('0.3 + 0.7 = ', x + y)
end.
Prev Up Next

Prev Up
Exercice 4.1
L'écriture en base 2 de 357 est 101100101.
Exercice 4.2
● On suppose que sont codés des entiers naturels sur 8 bits. Pour décoder, il suffit de regrouper les
bits 8 par 8, et de calculer pour chacun des octets ainsi obtenus, le nombre qui y est codé : le
premier octet 00111100 code l'entier 60 ...Le message complet code la liste suivante d'entiers :
60 42 35 99 101 99 105 33 40 101 115 116 41 38 117 110 63 43 109 101 115
115 97 103 101 33 45 115 117 98 108 105 109 105 110 97 108 35 42 62
● On suppose que sont codés des entiers naturels sur 16 bits. Le décodage est le même, mais en
regroupant les bits 16 par 16.
Les entiers codés par le message sont :
15402 9059 25955 26913 10341 29556 10534 30062 16171 28005 29555
24935 25889 11635 30050 27753 28009 28257 27683 10814
● On suppose que sont codés des caractères.

Pour décoder ce message, on peut utiliser le décodage en entiers 8 bits, puis consulter la table du
code ASCII. On obtient alors le message suivant :
<*#ceci!(est)&un?+message!-subliminal#*>
Exercice 4.3
Le résultat du calcul dépend de la machine utilisée et en particulier du codage des nombres réels, ainsi
que de la façon de tronquer ou d'arrondir les calculs.
Avec le codage IEEE double précision, on obtient le résultat suivant :
0.3 + 0.7 = 9.99999999999999945E-0001
Ce nombre, que l'on pourrait écrire :
0.999999999999999945
est proche de 1 à :

2-52 = 2.22044604925* 10-16 près, qui est l'erreur relative commise en représentant un réel dans ce
format.
Prev Up

Cours d'Informatique -- 5.3 Programmer
Prev Up Next
Précédent : 5.2 Un exemple de traitement générique : le tableur
Remonter : 5 Traiter l'information
Suivant : Exercices
5.3 Programmer
Programmer, outre l'aspect communication, consiste à décrire les traitements (calculs) à effectuer sur les
variables du programme. Les traitements possibles dépendent du type de chaque variable.
La manière la plus simple de décrire un traitement consiste à écrire une "expression". Ceci a déjà été
utilisé dans l'exemple : (revenu*0.25)-(nbparts*5260) est une expression.
Expression : une expression est une formule pouvant être :
● soit une constante, par exemple la constante entière : 1789, la constante réelle : 3.1415926536, la
chaîne de caractères : 'bonjour Monsieur', le booléen : vrai,
● soit une variable, on écrit alors son nom, par exemple : revenu, MontantEnFrancs,
● soit la combinaison par une opération d'une ou plusieurs expressions. On peut ainsi fabriquer des
expressions arbitrairement complexes, en utilisant les parenthèses pour délimiter les constituants
d'une expression.
Une expression a :
● un type, que l'on peut déduire de son écriture et des types de ses constituants
● une valeur, qui est calculée à l'exécution : on parle d'évaluation de l'expression.
Les opérations possibles dans l'écriture d'une expression sont celles vues lors de la présentation des
types. Le tableau suivant donne des exemples d'expressions ainsi que leur types. Ces expressions sont
correctes, si l'on suppose que les variables : x,y,z sont entières, les variables : a,b,c booléennes, et
les variables : m,n des chaînes de caractères.
Expression
Type
x + (y * z) - 4 Entier
(x + (y * z) - 4) < 13 Booléen
((x + (y * z) - 4) < 13) et ((x + 1) > y) Booléen
faux Booléen
non (a) et (b ou c) Booléen
(non (a) et (b ou c)) = faux Booléen
'bonjour' + 'monsieur' Chaîne
m + 'bonjour' + 'monsieur' + n Chaîne
((x + (y * z) - 4) < 13) ou (non (a) et (b ou c)) Booléen

Cours d'Informatique -- 5.3 Programmer
Les parenthèses permettent ici d'indiquer dans quel ordre, doivent s'effectuer les opérations. En l'absence
de parenthèses, l'usage mathématique est d'effectuer les multiplications avant les additions : par exemple
2 + 3 * 4 vaut 14. On dit alors que : la priorité de la multiplication est supérieure à celle de
l'addition. Concernant l'ensemble des opérateurs, leurs priorités relatives varient d'un langage à l'autre : il
convient donc d'être prudent, en mettant plutôt trop de parenthèses que pas assez.
Il est possible ainsi de décrire des calculs très complexes. Cependant, en pratique, le programmeur
préfère décrire une succession de calculs en passant par des résultats intermédiaires à mémoriser dans des
variables. Ceci est possible grâce à la notion d'affectation.
Affectation : l'affectation de la valeur d'une expression à une variable est une instruction élémentaire
consistant à calculer la valeur de l'expression puis à mémoriser ce résultat sous le nom de la variable
indiquée. L'affectation est notée :
nom de variable <- expression, qui se lit : la variable prend pour valeur l'expression. A noter que :
● Les types de l'expression et de la variable doivent être compatibles.
● La valeur de la variable avant l'affectation, est définitivement oubliée après.
Pour définir dans un algorithme, ou un programme les traitements que l'ordinateur doit effectuer, on peut
écrire la "séquence" des opérations à effectuer les unes après les autres.
Séquence : on appelle séquence d'instructions, l'écriture d'une liste d'instructions destinées à être
exécutées de la première, à la dernière, chacune s'exécutant quand l'exécution de la précédente est
terminée. On parle alors d'exécution séquentielle. Les instructions élémentaires pouvant être exécutées
séquentiellement sont :
● la lecture, notée : lire
● l'écriture, notée : ecrire

● l'affectation, notée : nom de variable <- expression
Remarque : Il existe d'autres manières d'écrire des algorithmes, sans définir explicitement l'ordre dans lequel les
opérations doivent être exécutées. Elles ne seront pas étudiées dans le cadre de ce cours.
L'ensemble des notions nécessaires étant précisées - variable, type, expression affectation, séquence -
l'art et la manière d'écrire des algorithmes peut dès lors être définitivement établie.
● Ecriture d'un algorithme
● De l'algorithme au programme Pascal ou JavaScript

Prev Up Next

Cours d'Informatique -- 11 Référence rapide du langage Pascal
Prev Up Next
Précédent : 10 Informations sur quelques logiciels d'usage courant
Remonter : Top
Suivant : 12 Référence rapide du langage JavaScript
11 Référence rapide du langage Pascal

Décrire un langage de programmation ne peut se faire en quelques lignes. Les informations contenues
dans cette annexe, ne peuvent donc remplacer les nombreux livres écrits sur le sujet, ni les
documentations techniques fournies avec un compilateur particulier du langage.
On a cependant regroupé l'essentiel des connaissances techniques nécessaires au programmeur débutant
en Pascal, tant en ce qui concerne la syntaxe du langage que les modalités pratiques de mise en oeuvre.
● Syntaxe
● Déclarations et types
● Compilation et exécution

Prev Up Next

Cours d'Informatique -- 12 Référence rapide du langage JavaScript
Prev Up Next
Précédent : 11 Référence rapide du langage Pascal
Remonter : Top
Suivant : 13 Quelques commandes de base des systèmes d'exploitation
12 Référence rapide du langage

JavaScript
The JavaScript name is a trademark or registered trademark of Sun Microsystems, Inc. in the United States and other
countries and is used under license.
Le langage JavaScript est disponible gratuitement, sous licence. Il est normalisé en Europe sous le
standard ECMA-262 et est en cours de normalisation internationale (ISO/IEC JTC 1). JavaScript est
intégré aux logiciels de navigation récents. La mise en oeuvre d'un programme est ainsi particulièrement
simple puisqu'il suffit de l'intégrer dans une page internet pour pouvoir l'exécuter.
Pour tester un exemple de programme simple, le modifier, ou saisir et tester un autre programme, on peut
utiliser la fenêtre JavaScript en cliquant ci-dessous.
● Syntaxe du langage JavaScript
● Interprétation d'un programme JavaScript

Prev Up Next

Cours d'Informatique -- 6 Commencer à programmer
Prev Up Next
Précédent : 5 Traiter l'information
Remonter : Top
Suivant : 7 Pour bien programmer
6 Commencer à programmer
Les chapitres précédents ont permis d'introduire progressivement le principe de base de la
programmation : prévoir les communications, et les traitements, tout en montrant "comment" cela peut
fonctionner grâce au codage de l'information.
Le traitement de problèmes informatiques complexes nécessite maintenant de résoudre les
problématiques suivantes :
● L'ordinateur fait toujours ce qui est écrit dans son programme. Cependant pour que le traitement
s'adapte aux demandes de l'utilisateur, il faut prévoir que le traitement à effectuer puisse dépendre
des données fournies. Un algorithme (ou un programme) doit donc permettre d'exprimer des
"traitements conditionnels".
● L'ordinateur, par nature (ou par construction), est particulièrement adapté aux "traitements
répétitifs" : exécuter les mêmes instructions un certain nombre de fois. Alors, pour éviter au
programmeur d'écrire un (très long) programme comportant "un certain nombre de fois" les mêmes
instructions, il faut lui fournir le moyen d'exprimer que tel traitement doit être répété.
● L'ordinateur est aussi particulièrement adapté à traiter de grandes quantités d'informations, qui
souvent ont une structure régulière : par exemple, une série de noms constituant un annuaire, un
tableau à 2 entrées de mesures effectuées en physique, une image constituée de points rangés en
lignes et en colonnes ...Pour cela, on peut introduire la notion de "tableau", permettant au
programmeur de décrire globalement le traitement à effectuer pour chaque élément d'un tableau.
● 6.1 Traitements conditionnels
● Exercices
● 6.2 Traitements répétitifs
● Exercices
● 6.3 Traitements de tableaux
● Exercices

Prev Up Next

Cours d'Informatique -- 5.1 Un exemple : le traitement de texte
Up Next
Suivant : 5.2 Un exemple de traitement générique : le tableur
5.1 Un exemple : le traitement de texte

Pour saisir l'intérêt d'un logiciel de traitement de texte, il suffit de le comparer à une machine à écrire
mécanique :
● La machine à écrire permet de taper un texte au clavier (organe d'entrée), et de l'imprimer
directement sur papier grâce à un dispositif mécanique.
● En utilisant un traitement de texte, entre la saisie (au clavier), et l'impression (sur imprimante),
l'ordinateur permet la mémorisation d'un document, sa visualisation, sa duplication, sa
modification manuelle ou automatique.
Parmi les fonctions usuelles d'un logiciel de traitement de texte, on peut citer :
● La "justification" (passage à la ligne) et la mise en page (alignement, tabulation, entête, bas de
page, numérotation ...) qui peuvent être manuelles (à la demande de l'utilisateur) ou automatiques.
● Les fonctions d'édition (couper, copier, coller) permettant de modifier un texte.
● Le choix
❍ des caractères à utiliser pour la visualisation et l'impression : voici une police de

caractères, une autre,
❍ de leur taille (aussi appelée "corps"),
❍ et de leur style : gras, italique ...
● La correction orthographique ou syntaxique ; la correction orthographique est basée sur la

comparaison automatique des mots saisis avec ceux enregistrés dans un dictionnaire (ne pas
s'étonner si le traitement de texte indique une faute à son nom de famille); la correction syntaxique
est plus rarement disponible, car le problème est très difficile - par exemple l'accord avec le
complément d'objet direct, les ellipses.
● La possibilité d'inclure et de manipuler des informations "graphiques" (dessins, schémas, tableaux,
photos ...)
● Les nécessaires fonctions de gestion des documents (fichiers) : ouvrir, enregistrer, imprimer,
permettant de conserver les textes, chacun sous un nom, puis de les modifier ou de les imprimer au
moment voulu.
Les logiciels dits de PAO (publication assistée par ordinateur), permettent de plus à l'utilisateur :
● de structurer un document (chapitres, sections, appendices ...) et de l'assister en fabriquant
certaines parties du texte automatiquement (dans ce cours, c'est le cas de la table des matières, de
l'index, des entêtes de page et de toutes les numérotations).
● de respecter automatiquement des "règles typographiques" : par exemple, la taille d'un titre de
chapitre doit être relative à la taille de caractère utilisée dans le texte. L'utilisateur indique par une

Cours d'Informatique -- 5.1 Un exemple : le traitement de texte
"feuille de style" ou une commande qu'il veut écrire un livre ; il ne lui reste plus alors qu'à indiquer
où sont les entêtes de chapitres, sans se préoccuper de prévoir le passage en gras ou le changement
de taille de caractères.
Du point de vue du programmeur
Deux types de codages sont utilisés par un traitement de texte :

● Un codage de type "suite de caractères" entrecoupé d'annotations codant les indications de mise en
page et de style. Ceci est très proche de ce que l'utilisateur saisit. C'est dans ce type de format que
les documents sont enregistrés pour pouvoir être modifiés ensuite.
● Un codage de type "image". Ce codage est utilisé pour visualiser un texte à l'écran, pour l'imprimer
ou pour l'envoyer par télécopie.
Le programme du traitement de texte consiste ainsi, en permanence :
● à mémoriser le texte saisi et les indications fournies par l'utilisateur, selon le premier codage,
● tout en transformant ce texte en image à l'écran, selon le second codage.
Exemple :
Voici une suite de caractères
Le tableau ci-dessus montre un texte, et l'image d'un texte. Cliquer dedans pour essayer de sélectionner
un mot. C'est possible dans le texte, mais pas dans l'image : seul l'utilisateur "voit" les mots dans l'image :
pour l'ordinateur c'est un tableau de points noirs ou blancs.
Up Next

Cours d'Informatique -- 5.2 Un exemple de traitement générique : le tableur
Prev Up Next
Précédent : 5.1 Un exemple : le traitement de texte
Suivant : 5.3 Programmer
5.2 Un exemple de traitement générique : le tableur

Tableur : un tableur est un logiciel permettant de réaliser des tableaux, comportant des éléments de texte ou des
valeurs numériques, saisies par l'utilisateur ou calculées à partir de formules fournies par l'utilisateur
L'utilisation d'un tableur s'apparente à la fois :
● à l'utilisation de n'importe quel logiciel (comme un traitement de texte), par ses possibilités d'édition, de
mise en page, d'impression et de mémorisation dans un fichier,
● à la programmation : en effet, pour définir le résultat devant s'afficher dans une "cellule" du tableau,
l'utilisateur introduit une formule pouvant dépendre de la valeur d'autres cellules et comportant des
opérations arithmétiques et/ou logiques.
Exemple :
La figure suivante montre l'utilisation d'un tableur, pour convertir des Francs en Euros. L'utilisateur a saisi :
● Dans les cellules A1, A3 et B3 des "chaînes de caractères",
● Dans la cellule A5, le nombre : 100
● Dans la cellule B5, la formule : = A5 / 6.55957
Le résultat affiché dans la cellule B5 a été calculé par le tableur.

Cours d'Informatique -- 5.2 Un exemple de traitement générique : le tableur
Exemple de tableur
Du point de vue du programmeur
Le programme du tableur consiste à attendre les valeurs et formules données par l'utilisateur et à les enregistrer
dans la cellule courante (celle qui est encadrée dans l'exemple), et à recalculer sans cesse les valeurs devant
s'afficher dans toutes les cellules, ceci en exécutant les "morceaux de programme" (formules) fournis par
l'utilisateur.
Ces formules s'écrivent de la même manière que les expressions, telles qu'utilisées dans les algorithmes et
langages de programmation (aux noms près des opérateurs, qui peuvent varier d'un logiciel à un autre).
Prev Up Next

Prev Up Next
Précédent : 5.3 Programmer
Exercices
Exercice 5.1 : Simulation: lire-traiter-écrire
L'algorithme suivant effectue quelques calculs simples avec 2 entiers x et y demandés à l'utilisateur. Les
numéros de lignes ne font pas partie de l'algorithme, mais servent uniquement à repérer les instructions.
Algorithme melange
{ Simples calculs avec 2 entiers... }
x entier demandé à l'utilisateur
y entier demandé à l'utilisateur
début
1 ecrire('Bonjour, donnez-moi un nombre entier :');

2 lire (x);
3 ecrire('Un autre SVP :');
4 lire (y);
5 x := x + y ;
6 y := x - y ;
7 x := x - y ;
8 ecrire ('Voila le résultat : ', x,' ', y);
fin
Remplir le tableau suivant, en indiquant pour chaque ligne la valeur des variables de l'algorithme et les
affichages à l'écran, après l'exécution de la ligne correspondante. On suppose que l'utilisateur a fourni
successivement les valeurs : 18 et 13.
n x y Affichage à l'écran
1
2
3
4
5

6
7
8
Exercice 5.2 : Unités de longueur métriques et anglo-saxonnes

Ecrire un algorithme qui:
● étant donné une longueur, demandée à l'utilisateur, exprimée en pieds et pouces (en utilisant des
variables de type approprié) - on supposera que les valeurs saisies sont plausibles,
● calcule cette longueur en mètres (en valuant une variable de type approprié),
● puis affiche le contenu de cette variable.
On rappelle qu'un pied est égal à 12 pouces, et qu'un pouce vaut 2.54 cm.
Ecrire un algorithme qui:
● étant donné une longueur, demandée à l'utilisateur, exprimée par un nombre entier de centimètres,
● calcule une longueur équivalente exprimée en pieds et pouces,
● puis affiche le résultat.
Exercice 5.3 : Echange et permutation circulaire

En utilisant deux variables de type entier nommées par exemple x et y, écrire un algorithme qui:
● demande à l'utilisateur le contenu de ces deux variables (l'utilisateur donnera des valeurs
distinctes),
● affiche dans cet ordre x puis y,
● intervertit le contenu de ces deux variables et enfin
● affiche à nouveau x puis y
Le but de cet exercice est d'échanger le contenu de deux variables et non pas d'en intervertir l'affichage. L'affichage des
variables avant et après l'échange est seulement demandé pour permettre la vérification de l'échange.
En utilisant trois variables de type caractère nommées l1, l2 et l3, écrire un algorithme qui:
● demande à l'utilisateur un contenu différent pour ces trois variables
● affiche dans cet ordre l1, l2 puis l3,
● effectue une permutation circulaire à droite des contenus de ces trois variables et enfin
● affiche à nouveau l1, l2 puis l3.

Prev Up Next

Prev Up
Exercice 5.1
n x y Affichage à l'écran
1 ? ? Bonjour, donnez-moi un nombre entier :
2 18 ?
3 18 ? Un autre SVP :
4 18 13
5 31 13
6 31 18
7 13 18
8 13 18 Voila le résultat : 13 18
Exercice 5.2
Une solution pour le premier algorithme demandé peut être la suivante :

Algorithme PiedsEtPoucesEnMetres
{ Convertit une longueur exprimée en pieds et pouces en une longueur équivalente en mètres }
LPieds entier donnée
Lpouces entier donnée
TotalEnPouces entier calcul intermédiaire
LMetres réel résultat
début
ecrire('Donnez votre taille en pieds : ')

lire (LPieds)
ecrire('Et en pouces : ')
lire (Lpouces)

TotalEnPouces <-- ((12 * LPieds) + Lpouces)

LMetres <-- (TotalEnPouces * 2.54) / 100
ecrire ('Vous mesurez : ', LMetres, ' metres')
fin
Pour la conversion réciproque, le principe est le même. Pour effectuer la répartition entre nombre entiers
de pieds et de pouces, on utilise la division entière (div) et son reste (mod).
Comparer vos résultats avec ceux du programme JavaScript à exécuter ci-dessous.
Exercice 5.3
L'algorithme demandé a la forme suivante :

Algorithme Echange
{ Echange de 2 variables... }
x entier demandé à l'utilisateur
y entier demandé à l'utilisateur
z entier variable intermédiaire
début
ecrire('Bonjour, donnez-moi un nombre entier :');

lire (x);
ecrire('Un autre SVP :');
lire (y);
ecrire ('Avant echange : ', x,' ', y);
... { A COMPLETER }
ecrire ('Apres echange : ', x,' ', y);
fin
Pour réaliser l'échange, on a besoin d'une variable intermédiaire. Pour trouver une solution, sans calculs,
il suffit de penser à la suite des enregistrements nécessaires si l'on veut avec un magnétophone à 2
cassettes, enregistrer le contenu de l'une sur l'autre et réciproquement.
La solution ainsi obtenue, pourrait fonctionner pour n'importe quel type de variables, à condition qu'elles
soient toutes du même type. Elle peut ainsi facilement se généraliser au cas du second algorithme
demandé, où il faut permuter 3 variables de type caractère.

Prev Up

Cours d'Informatique -- Syntaxe des expressions
Prev Up Next
Précédent : Syntaxe d'un programme et des instructions
Remonter : Syntaxe
Suivant : Syntaxe des déclarations
Syntaxe des expressions

::= ( entre parenthèses,
expression expression pour imposer
) l'ordre des calculs
| expression egalité
=
expression
| expression inférieur
<
expression
| expression supérieur
>
expression
| expression inférieur ou égal
<=
expression
| expression supérieur ou égal
>=
expression
| expression différent
<>
expression
| expression addition (pour
+ entiers ou réels)
expression concaténation(pour
chaines de
caractères)
| expression soustraction (pour
- entiers ou réels)
expression
| expression ou (pour booléens)
or
expression

| expression multiplication
* (pour entiers ou
expression réels)
| expression division (pour
/ entiers ou réels)
expression
| expression division entière
div
expression
| expression reste de la division
mod entière
expression
| expression et (pour booléens)
and
expression
| not non
expression
| - opposé (pour entier
expression ou réel)
| nom ( appel d'une
expression fonction
{,
expression
})
| abs( valeur absolue
expression (pour entier ou
) réel)
| sqr( carré (pour entier
expression ou réel)
)
| sqrt( racine carrée (pour
expression entier ou réel)
)
| trunc( troncature (pour
expression un réel)
)
| round( arrondi (pour un
expression réel)
)

| cos( cosinus(pour un
expression réel)
)
| sin( sinus (pour un
expression réel)
)
| variable nom d'une variable
| constante entier, réel,
booléen, chaîne ou
caractère
REMARQUE : en absence de parenthèses, les opérations binaires arithmétiques : *, +, -, /, div mod,

logiques : and, or, et de comparaison : =, < >, <=, >=, <> sont calculées dans l'ordre suivant :
● d'abord les opérations : *, /, div, mod, and
● ensuite : +, -, or
● puis : =, <, >, <=, >=, <>
A niveau équivalent, en l'absence de parenthèses, les opérations sont calculées de gauche à droite; les
opérations à un argument (dites opérations unaires) not, -, sont calculées avant les opérations binaires.
● 2 + 3 * 4, est calculé comme : 2 + (3 * 4)
● 2 < 3 and 3 < 4, est compris comme : (2 < (3 and 3)) < 4, ce qui n'a pas de sens. Il
faut écrire : (2 < 3) and (3 < 4)
● 2 + 3 * 4 = 2 - 3 / 4, est calculé comme : (2 + (3*4))=(2 - (3/4))
● true or false and not true, est calculé comme : true or (false and (not
true))
::= suite de nom de
variable lettres et de la
chiffres, variable
commençant
par une
lettre
| variable [ élément
expression d'un
] vecteur
::= suite de constante

constante chiffres entière
positive
| - suite de constante
chiffres entière
négative

| suite de constante
chiffres réelle
comportant
un point
décimal
et/ou un
exposant
| true constante
booléenne:
vrai
| false constante
booléenne:
faux
| un constante
caractère caractère,
entre : ' ' par
exemple :
'a'
| une suite constante
de chaîne de
caractères caractères,
entre : ' ' par
exemple :
'bonjour'

Prev Up Next

Cours d'Informatique -- Ecriture d'un algorithme
Up Next
Remonter : 5.3 Programmer
Suivant : De l'algorithme au programme Pascal ou JavaScript
Ecriture d'un algorithme

L'écriture d'un algorithme comporte :
● un titre (pour le retrouver facilement dans une pile de papiers !)
● quelques commentaires décrivant son utilité, ses éventuelles restrictions d'usage, et expliquant brièvement le
principe du traitement
● un lexique de toutes les variables utilisées dans l'algorithme, décrivant pour chacune d'entres elles :
❍ son nom, si possible "intuitif" (plutôt revenu que zz92),
❍ son type (entier, réel, chaîne, caractère, booléen ...),
❍ son utilité
● la séquence des instructions à exécuter (dans l'ordre, évidemment!), que l'on délimite par les mots début et fin,
pour éviter de "mélanger" des algorithmes entre eux.
Un algorithme ainsi décrit peut ensuite être facilement traduit vers n'importe quel langage de programmation, et être
compris par n'importe quel programmeur.
Exemple : L'algorithme CalculMiMaree calcule l'heure et la hauteur d'eau à mi-marée après avoir demandé à
l'utilisateur les heures et hauteurs de la basse mer et de la pleine mer. La mi-marée est définie comme le temps au milieu
entre les heures de basse mer et pleine mer ; la hauteur d'eau est alors la moyenne des hauteurs à basse mer et à pleine
mer.
Pour représenter, un temps, par exemple 10H24, on peut utiliser 2 nombres entiers, un pour le nombre d'heures, l'autre
pour le nombre de minutes. L'algorithme demande à l'utilisateur 2 entiers pour chacun des temps de marée basse et
haute et doit calculer les 2 entiers caractérisant l'heure de mi-marée. Il calcule de plus avec des nombres réels la hauteur
d'eau.
Voici un exemple d'exécution possible pour cet algorithme (sont notées en gras les données fournies par l'utilisateur) :
Heure de la maree basse ? Heure : 10

Minute : 24
Hauteur d eau a maree basse ? 1.10
Heure de la maree haute ? Heure : 18
Minute : 52
Hauteur d eau a maree haute ? 5.40
La mi-maree est a : 14H38
avec la hauteur d eau : 3.25 m
Algorithme CalculMiMaree
{ Calcule le temps et la hauteur de la mi-marée, en fonction des temps et hauteurs des marées haute et basse. Pour
calculer le temps de la mi-marée convertit les temps en minutes pour faire la moyenne, et convertit le resultat en heures
et minutes }
HBas entier Heure de la marée basse
MnBas entier Minute de la marée basse
HHaut entier Heure de la marée haute

Cours d'Informatique -- Ecriture d'un algorithme
MnHaut entier Minute de la marée haute

HMi entier Heure de la mi-marée
MnMi entier Minute de la mi-marée
TempsBas entier Temps compté en mn depuis 0h00 de la marée basse
TempsHaut entier Temps compté en mn depuis 0h00 de la marée haute
TempsMi entier Temps compté en mn depuis 0h00 de la mi-marée
HauteurHaut reel Hauteur d'eau à marée haute
HauteurBas reel Hauteur d'eau à marée basse
HauteurMi reel Hauteur d'eau à mi-marée
début
ecrire ('Heure de la maree basse ? Heure :')

lire (HBas)
ecrire ('Minute :')
lire(MnBas)
ecrire ('Hauteur d eau a maree basse ?')
lire (HauteurBas)
ecrire ('Heure de la maree haute ? Heure :')
lire (HHaut)
ecrire ('Minute :')
lire(MnHaut)
ecrire ('Hauteur d eau a maree haute ?')
lire (HauteurHaut)
TempsBas <-- 60 * HBas + MnBas { conversion des heures/minutes }
TempsHaut <-- 60 * HHaut + MnHaut { en nombre de minutes depuis 0H00 }
HauteurMi <-- (HauteurBas + HauteurHaut)/2 { moyenne des hauteurs }
TempsMi <-- (TempsBas + TempsHaut) div 2 { division entière par 2 }
HMi <-- TempsMi div 60 { division entière par 60 }
MnMi <-- TempsMi mod 60 { reste de la division par 60 }
ecrire ('La mi-maree est a : ', HMi, 'H', MnMi)
ecrire ('avec la hauteur d eau : ', HauteurMi , 'm')
fin
Up Next

Cours d'Informatique -- De l'algorithme au programme Pascal ou JavaScript
Prev Up
Précédent : Ecriture d'un algorithme
Remonter : 5.3 Programmer
De l'algorithme au programme Pascal ou JavaScript

Un programme comporte au moins une séquence d'instructions (en Pascal et en Javascript). En Pascal il
doit de plus avoir un nom, et respecter la syntaxe suivante :
program nom ;
declarations
begin
sequence
end.
Une séquence d'instructions est une liste d'instructions séparées par des point-virgules.
instruction ;
...
instruction
Les déclarations de variables ont la forme suivante en Pascal :

var
nom { , nom } : type ;
...
nom { , nom } : type ;
En JavaScript la forme d'un programme doit être la suivante :

[ Declarations ]
Sequence
Une séquence d'instructions est une liste d'instructions séparées par des passage à la ligne et/ou des
point-virgules.
Instruction ;
...
Instruction
En JavaScript, les déclarations (sans indication de type) peuvent avoir la forme suivante :
var Nom { , Nom }
Les instructions élémentaires (affectation/lecture/écriture) s'écrivent selon les formes suivantes, en

Pascal :

variable := expression
readln( variable { , variable } )
writeln( expression { , expression } )
Et en JavaScript :
Variable = Expression
Variable = prompt(' Chaine de caractères ', Expression )
alert( Expression )

Prev Up

Cours d'Informatique -- 7 Pour bien programmer
Prev Up Next
Précédent : 6 Commencer à programmer
Remonter : Top
Suivant : 8 Pour aller plus loin
7 Pour bien programmer

Les chapitres précédents ont présenté les principales constructions accessibles au programmeur pour
décrire les traitements qu'il souhaite faire exécuter à la machine.
La difficulté de sa tâche est la maîtrise de la complexité intrinsèque des traitements à effectuer. Pour
réussir la programmation d'un système complexe (c'est-à-dire pouvant comporter un grand nombre de cas
différents à traiter, ou de traitements différents successifs, ou de traitements répétitifs) l'informaticien
doit agir avec méthode.
L'informaticien est un "architecte" qui sait composer des traitements complexes avec les "briques" dont il
dispose : les instructions. Sa démarche est de décomposer un problème complexe en plusieurs problèmes
indépendants les uns des autres et moins complexes. Il peut aussi reconnaitre un "schéma" de problème,
dont il a déjà donné une solution par ailleurs ; il n'a alors plus à ré-inventer cette solution.
L'exemple suivant permet d'illustrer dans la suite de ce chapitre :
● la méthode de décomposition d'un problème en sous-problèmes (méthode aussi appelée analyse
descendante), et sa mise en oeuvre par des fonctions et des procédures,
● la méthode d'analyse des traitements répétitifs par reconnaissance d'un schéma usuel.
● 7.1 Décomposer les traitements
● 7.2 Fonctions et procédures
● Exercices
● 7.3 Analyser les traitements répétitifs
● Exercices

Prev Up Next

Cours d'Informatique -- 6.1 Traitements conditionnels
Up Next
Remonter : 6 Commencer à programmer
Suivant : Exercices
6.1 Traitements conditionnels

Pour que le choix d'un traitement à effectuer puisse dépendre des données fournies par l'utilisateur, le
principe est le suivant :
● on doit prévoir un calcul à résultat booléen (vrai ou faux), c'est-à dire écrire une expression avec
des opérateurs donnant un résultat booléen, par exemple : (x<=4) et (2*x>=2)
● on prévoit les traitements à effectuer ou à ne pas effectuer selon le résultat (vrai ou faux) de ce
calcul, selon les données fournies par l'utilisateur.
Tous les langages de programmation offrent divers moyens de contrôler de cette façon les traitements à
effectuer.
Pour l'écriture d'un algorithme (indépendant d'un langage particulier) on utilise les constructions
suivantes :
● la construction conditionnelle : si... alors
● la construction alternative : si... alors... sinon
Pour résoudre des problèmes plus complexes (plus de 2 cas), on peut de plus :
● composer entre elles ces constructions,
● composer avec des opérations booléennes,
● ou utiliser une construction prévoyant un choix selon des valeurs énumérées.
● Exemple introductif
● La construction conditionnelle
● La construction alternative
● Composition de ces constructions
● Utilisation d'opérations booléennes
● Quelques équivalences entre constructions
● Choix selon des valeurs énumérées

Up Next

Prev Up Next
Précédent : 6.1 Traitements conditionnels
Exercices
Les algorithmes demandés pourront être traduits en Pascal ou en JavaScript en suivant la syntaxe donnée en annexe.
Exercice 6.1 : Simulation: si

Simuler le fonctionnement de l'algorithme suivant, en notant pour chaque ligne exécutée, les valeurs des variables après
l'exécution de la ligne correspondante.
Algorithme
{ A étudier }
x,y,z entiers
début
1 x <- 12 y <- 3 z <- 5

2 si x > z alors y <- x fin si
3 si y < z
4 alors x <- y + 1
5 sinon z <- y
fin si
fin
Exercice 6.2 : Calcul du maximum de 2 nombres
L'utilisateur donne deux valeurs entières distinctes. Ecrire un algorithme qui calcule dans une variable la valeur du plus
grand de ces deux nombres puis l'affiche.
Note : on peut écrire deux variantes :
● une avec si...alors...sinon...
● une avec si...alors...
Modifier l'algorithme pour calculer le maximum de 4 nombres distincts saisis par l'utilisateur.
Exercice 6.3 : Nombre de jours du mois
Ecrire un algorithme qui étant donné un nombre entier (compris entre 1 et 12), demandé à l'utilisateur, représentant un mois
d'une année, donne le nombre de jours de ce mois pour une année non bissextile.
Réécrire cet algorithme cette fois à partir de deux nombres entiers, demandés à l'utilisateur, le premier représentant un mois
et le deuxième une année (4 chiffres), pour donner le nombre de jours de ce mois en tenant compte des années bissextiles.
Rappelons qu'une année est bissextile si le millésime correspondant vérifie l'une des 2 propriétés suivantes :
● ou bien il est divisible par 4 et n'est pas divisible par 100
● ou bien il est divisible par 400.

Exemples : 1900 n'était pas une année bissextile, 1904 ...1996 étaient bissextiles, 2000 est une année bissextile.
On fera attention à écrire un algorithme qui passe l'an 2000 !
Exercice 6.4 : Travail pratique : compréhension d'un programme Java
Ce programme est une modification de l'algorithme de l'exercice de conversion de francs en euros permettant la conversion
dans les 2 sens.
Cet exemple est caractéristique de ce que doit écrire le programmeur - ici une instruction alternative - pour que le
programme s'adapte à la demande de l'utilisateur.
var MontantEnFrancs;
var MontantEnEuros;
var Sens;
Sens=prompt('Choisissez F: Francs->Euros E: Euros->Frans ', 'F');
if (Sens === 'F')
{ MontantEnFrancs=prompt('Donner un montant en Francs ', 0);
alert('La valeur en Euros est : ' + MontantEnFrancs / 6.55957)
}
else
{ MontantEnEuros=prompt('Donner un montant en Euros ', 0);
alert('La valeur en Francs est : ' + MontantEnEuros * 6.55957)
}
Exercice 6.5 : Travail pratique : compréhension d'un programme Pascal
Les deux programmes suivants ont pour objectif de calculer le prix d'une séance de cinéma en fonctions des règles
suivantes :
● le tarif réduit (35F) est accordé aux étudiants tous les jours sauf le dimanche,
● il est aussi accordé aux plus de 65 ans et aux moins de 18 ans du lundi au jeudi, et pour tous le mercredi,
● le tarif plein est de 45 F.
Voici une première version:
program cinema;
{ calcule le prix d'une place de cinema }
var jour,age : integer;
tarif_reduit : boolean;
reponse : char;
begin
writeln('Bienvenue au cinema');
writeln('Quel jour est-on ? Lun:1, Mar:2, Mer:3, Jeu:4, Ven:5,Sam:6,Dim:7');
readln(jour);
writeln('Quel age avez vous ?');
readln(age);
writeln('Etes-vous etudiant? o/n');
readln(reponse);
tarif_reduit := (jour = 3) or
((age <= 18) or (age >= 65)) and (jour <= 4) or
(jour < 7) and (reponse = 'o');
if tarif_reduit then writeln('Le prix est 35 F')
else writeln ('Le prix est 45 F')
end.

et une seconde, un peu plus complexe:
program cinema;
var jour,age : integer;
tarif_reduit : boolean;
reponse : char;
begin
writeln('Bienvenue au cinema');
writeln('Quel jour est-on ? Lun:1, Mar:2, Mer:3, Jeu:4, Ven:5,Sam:6,Dim:7');
readln(jour);
tarif_reduit := (jour = 3);
if (jour <> 3) and (jour < 7) then
begin
writeln('Quel age avez vous ?');
readln(age);
if ((age <= 18) or (age >= 65)) and (jour <= 4)
then tarif_reduit := true
else begin
writeln('Etes-vous etudiant? o/n');
readln(reponse);
tarif_reduit := (reponse = 'o')
end
end;
if tarif_reduit then writeln('Le prix est 35 F')
else writeln ('Le prix est 45 F')
end.
Analysez ces 2 programmes, tout d'abord en lisant leur texte, puis en les exécutant (après les avoir compilés - voir
informations techniques en annexe).
Peux-t-on encore améliorer le dialogue entre le programme et l'utilisateur, pour ne pas poser de questions inutiles ?
Prev Up Next

Prev Up Next
Suivant : 6.2 Traitements répétitifs
Exercice 6.1
Ligne x y z
DEBUT
Exercice 6.2
Solution avec la construction si...alors...sinon...

Algorithme Maxi
{ calcule et affiche le maximum de 2 entiers }
x,y entiers
max entier le maximum de x et y
début
ecrire ('Donnez un entier')

lire(x)
ecrire ('Donnez un entier')
lire(y)
si x > y
alors max <- x
sinon max <- y
fin si
ecrire ('le maximum est :', max)
fin
Solution avec la construction si...alors.... On remplace la partie comprise entre si et fin si dans la
solution précédente par :

max <- x
si y > max alors max <- y fin si
Pour calculer le maximum de 4 nombres, on peut déterminer le maximum des deux premiers nombres, le
maximum des deux derniers, puis le plus grand de ces deux maxima.
Une solution simple consiste à utiliser 4 variables a,b,c,d pour les données, 2 variables Maxab, Maxcd
pour les calculs intermédiaires et une variable Max pour le résultat. Il suffit alors de recopier 3 fois les
instructions calculant le maximum de 2 nombres en les adaptant aux maxima à calculer.
Exercice 6.3
La première version de l'algorithme peut être écrite :

● avec des constructions si...alors...sinon...
● ou avec la construction selon
pour différentier le calcul du nombre de jours en fonction du mois :

● 28 jours pour le mois 2
● 31 jours pour les mois : 1, 3, 5, 7, 8, 10, 12
● 30 jours pour les mois : 4, 6, 9, 11.
Le calcul en fonction des années bissextiles demande l'écriture d'un condition booléenne un peu plus
complexe, pour calculer le nombre de jours du mois de février. Si les variables an et mois contiennent les
numéros d'année et de mois, la condition pour qu'une année soit bissextile s'écrit :
(an mod 4 = 0 et non (an mod 100 = 0)) ou (an mod 400 = 0)
Remarque : l'expression x mod y = 0, en calculant le reste de la division de x par y et en le comparant à
0, permet de dire s'il est vrai que x est divisible par y.
Exercice 6.4
Pour vérifier que le programme a le comportement attendu, cliquer ci-dessous.

Exercice 6.5
Que pensez-vous des 2 programmes Pascal donnés ?

Ils posent toujours les memes questions Ils sont equivalents Ils calculent le meme resultat
Concernant l'ergonomie de ces programmes (absence de questions inutiles), il est bien sûr possible de
poser les questions dans un ordre différent pour ne pas, par exemple, demander son âge à un étudiant.
Mais cela peut alors amener à demander à un plus de 65 ans, s'il est étudiant.

Prev Up Next

Cours d'Informatique -- 6.2 Traitements répétitifs
Prev Up Next
Précédent : Corrigés et indications
Suivant : Exercices
6.2 Traitements répétitifs

L'objectif est de prévoir par programme la répétition de certains traitements, sans avoir à les répéter
(recopier) dans l'écriture du programme. Recopier ne serait d'ailleurs pas possible si l'on souhaite répéter
un calcul autant de fois que nécessaire pour que le résultat satisfasse une propriété donnée.
Exemple : On cherche à calculer le nombre d'années nécessaires, pour qu'une somme de 1000 F placée à
un taux annuel de 8,25%, ait atteint le double de sa valeur. Sans chercher de solution directe, on peut
répéter des multiplications par 1.0825 un certain nombre de fois... et prévoir que le calcul s'arrête dès que
le montant est supérieur à 2000.
Tous les langages de programmation offrent divers moyens de répéter les traitements. Pour l'écriture d'un
algorithme (indépendant d'un langage particulier) on utilise les constructions suivantes :
● la construction : tant que....
● la construction : répéter... jusqu'à...
● la construction : pour...
Ces constructions sont ensuite illustrées sur plusieurs exemples, comportant ou non des communications
avec l'utilisateur. En effet, les traitements répétitifs sont utilisés à la fois pour créer des "dialogues
répétitifs" et pour programmer des calculs complexes où la répétition n'est pas explicite pour l'utilisateur.
● La construction : Tant que
● La construction : Répéter
● La construction : Pour
● Exemples de traitements répétitifs

Prev Up Next

Prev Up Next
Précédent : 6.2 Traitements répétitifs
Exercices
Les algorithmes demandés pourront être traduits en Pascal ou en JavaScript en suivant la syntaxe donnée
en annexe.
Exercice 6.6 : Simulation: tant que
Simuler le fonctionnement de l'algorithme suivant :
Algorithme algo1
{ Sans commentaire }
N entier valeur courante de la suite
début
1 N <- 1
2 tant que N < 10
3 N <- N + 2
4 fin tant que
5 écrire ('N =', N)
fin
Exercice 6.7 : Comptage de mesures et moyenne
Ecrire un algorithme qui demande à l'utilisateur une suite de nombres, représentant des mesures ne
pouvant qu'être strictiment positives. L'utilisateur ne compte pas le nombre de mesures à saisir, mais
signale qu'il a terminé en entrant un nombre négatif ou nul. L'algorithme affiche alors le nombre de
mesures saisies, et leur moyenne arithmétique.
Exercice 6.8 : Deviner un nombre
Ecrire un algorithme, qui essaie de faire deviner un nombre (entier entre 1 et 100). Le joueur -
l'utilisateur du programme - doit proposer un entier; l'algorithme répond alors par '+' si le nombre à
deviner est plus grand, par '-' si le nombre à deviner est plus petit, et par un message indiquant qu'il a
gagné quand le nombre proposé est égal au nombre à deviner.
Pour assister le joueur, on peut écrire un autre algorithme, pour proposer intelligemment au joueur

d'essayer un nombre en tenant compte de toutes les réponses '+', '-' déjà fournies par le premier
algorithme.
Exercice 6.9 : Affichage des heures et hauteurs de marée
En reprenant les indications données pour l'algorithme de calcul de la mi-marée, on cherche à afficher le
tableau heure par heure des hauteurs d'eau entre la marée basse et la marée haute.
Voici un exemple d'exécution possible pour cet algorithme (sont notées en gras les données fournies par
l'utilisateur) :
Heure de la maree basse ? Heure : 10

Minute : 24
Hauteur d eau a maree basse ? 1.10
Heure de la maree haute ? Heure : 16
Minute : 52
Hauteur d eau a maree haute ? 5.40
| HEURE |HAUT. |
| 10h24 | 1.10 |
| 11h28 | 1.46 |
| 12h33 | 2.18 |
| 13h38 | 3.25 |
| 14h42 | 4.33 |
| 15h47 | 5.04 |
| 16h52 | 5.40 |
La méthode de calcul est la suivante. Le temps entre marée basse et marée haute est divisée en 6 parties
égales appelée "heure marée" (dans cet exemple environ 1h04). La différence de hauteur entre marée
basse et marée haute est divisée en 12 parties (appelées douzièmes). La mer monte de 1 douzième
pendant la première et la sixième heure de marée montante, de 2 douzièmes pendant la deuxième et la
cinqième heure de marée montante, et de 3 douzièmes pendant les troisième et quatrième heures.
Ecrire en adaptant l'algorithme de calcul de la mi-marée, un algorithme qui affiche le tableau des heures
et hauteurs pendant la marée montante.
Exercice 6.10 : Calcul d'une suite de Syracuse
A un entier n strictement positif on associe n/2 si n est pair et 3n+1 si n est impair. En réappliquant cette
transformation à l'entier obtenu, on définit un algorithme dit de Syracuse.
Bien qu'à ce jour personne n'en ait trouvé de démonstration, il semble que pour tout entier strictement
positif de départ on finisse toujours par arriver à 1.
On demande d'écrire un algorithme qui, pour une valeur de départ proposée par l'utilisateur, affiche la
liste des entiers obtenus jusqu'à 1, ainsi que le nombre de fois qu'il est nécessaire d'appliquer la
transformation pour y arriver (ou, si l'on part de 1, pour y revenir). Voici un exemple de déroulement de
cet algorithme :

Valeur de départ (entier strictement positif) ? 12

6 3 10 5 16 8 4 2 1
On doit appliquer 9 fois la transformation avant d'arriver à 1.
Prev Up Next

Prev Up Next
Suivant : 6.3 Traitements de tableaux
Exercice 6.6
Ligne N
DEBUT
Exercice 6.7
L'idée de base de l'algorithme est de mémoriser au cours de la saisie des mesures, leur nombre et leur somme. Il ne reste plus, après
la saisie de toutes les mesures qu'à calculer la moyenne et à afficher les résultats demandés.
Algorithme Moyenne
{ Compte et calcule la moyenne d'une série de mesures }
Nombre entier nombre de mesures
Mesure réel mesure saisie
Somme réel somme des mesures
Moyenne réel Le résultat à calculer
début
Nombre <- 0 { Les variables Nombre et Somme sont nulles avant

la saisie }
Somme <- 0
ecrire ('Mesure ? (négatif pour finir)')
lire (Mesure)
tant que Mesure > 0
Nombre <- Nombre + 1 { on ne compte que les mesures positives }
Somme <- Somme + Mesure { et surtout pas la derniere valeur }
lire (Mesure)
fin tant que
Moyenne <- Somme / Nombre
écrire ('Nombre de mesures =', Nombre)
écrire ('Moyenne des mesures =', Moyenne)
fin
Exercice 6.8
Le programme JavaScript suivant commence par affecter la variable adeviner avec un nombre entier aléatoire. La fonction
Math.Random donne un nombre entre 0 et 1 dont on calcule un nombre entre 0 et 100. Ensuite, tant que l'utilisateur ne trouve pas
ce nombre, le programme l'indique par le message '+' ou '-'.

var adeviner, nombre, nbessais
adeviner= Math.ceil (100* Math.random())
nbessais = 0
do
{nombre = prompt('Nombre ?')
nbessais = nbessais + 1
if (nombre == adeviner)
alert ('Gagné en '+ nbessais + ' essais')
else if (nombre < adeviner)
alert ('+')
else alert ('-')
}
while (adeviner != nombre)
Pour jouer, cliquer ci-dessous; attention, ce programme ne s'arrête que quand l'utilisateur a trouvé le bon nombre.
Pour gagner au plus vite, le principe (appelé dichotomie) est de toujours choisir un nombre au milieu de l'intervalle possible
(calculé à partir des réponses précédentes), on divise ainsi à chaque fois par deux le nombre de nombres à essayer. C'est ce que
calcule le programme ci-dessous. Les variables min et max sont mises à jour à chaque réponse du programme de devinette. Si à
l'essai proposé il a été répondu '+', alors il ne faudra proposer que des nombres à partir de essai + 1.
var message, min, max

min = 0
max = 100
essai = Math.ceil((min + max)/2)
message = prompt('Essayez '+essai + '(+/-/=)', '')
while (message != '=')
{
if (message == '+')
{min = essai+1}
else
{max = essai-1}
essai = Math.ceil((min + max)/2)
message = prompt('Essayez '+essai + '(+/-/=)', '')
}
Combien de coups, ce programme peut-il proposer avant de gagner ? Y-a-t-il un maximum ?
Exercice 6.9
Les informations à obtenir (temps et hauteurs des marées haute et basse) sont les mêmes que pour la calcul de mi-marée; l'affichage
heure par heure se fait par la construction répétitive pour en faisant varier de 1 à 6 de la première heure à la sixième heure de
marée montante.
A l'intérieur de la construction pour, se trouvent imbriquées 2 constructions si alors sinon pour que la calcul des variations
de hauteurs varie de la première à la sixième heure. Le calcul des temps (H et Mn) est le même répété 6 fois (seul l'indice i varie).
Algorithme CalculMaree
{ Calcule et affiche le tableau des temps et hauteur d'eau, heure par heure, pendant la marée montante }
HBas entier Heure de la marée basse
MnBas entier Minute de la marée basse
HHaut entier Heure de la marée haute
MnHaut entier Minute de la marée haute

TempsBas entier Temps compté en mn depuis 0h00 de la marée basse

TempsHaut entier Temps compté en mn depuis 0h00 de la marée haute
HauteurHaut reel Hauteur d'eau à marée haute
HauteurBas reel Hauteur d'eau à marée basse
H entier Heure à marée montante
Mn entier Minute à marée montante
Temps entier Temps compté en mn depuis 0h00 à marée montante
Hauteur reel Hauteur d'eau à marée montante
Hsur12 reel Douzième de la différence de hauteur
i entier indice
début
ecrire ('Heure de la maree basse ? Heure :')

lire (HBas)
ecrire ('Minute :')
lire(MnBas)
ecrire ('Hauteur d eau a maree basse ?')
lire (HauteurBas)
ecrire ('Heure de la maree haute ? Heure :')
lire (HHaut)
ecrire ('Minute :')
lire(MnHaut)
ecrire ('Hauteur d eau a maree haute ?')
lire (HauteurHaut)
TempsBas <- 60 * HBas + MnBas { conversion des heures/minutes }
TempsHaut <- 60 * HHaut + MnHaut { en nombre de minutes depuis 0H00 }
Hauteur <- HauteurBas
Hsur12 <- (HauteurHaut - HauteurBas) / 12
ecrire ('| HEURE |HAUT. |')
ecrire ('| ', HBas, 'h', MnBas, ' | ', HauteurBas , ' |')
pour i de 1 à 6
si (i = 1) ou (i=6)
alors Hauteur := Hauteur + Hsur12
sinon si (i = 2) ou (i=5)
alors Hauteur <- Hauteur + 2 * Hsur12
sinon Hauteur <- Hauteur + 3 * Hsur12
fin si
fin si
Temps <- TempsBas + i * (TempsHaut - TempsBas) div 6;
H <- Temps div 60 { division entière par 60 }
Mn <- Temps mod 60 { reste de la division par 60 }
ecrire ('| ', H, 'h', Mn, ' | ', Hauteur , ' |')
fin pour
fin
Exercice 6.10
L'algorithme suivant permet de parcourir une suite de Syracuse à partir d'un entier fourni par l'utilisateur, et jusqu'à arriver à 1. Le
nombre d'itérations n'étant pas connu à l'avance, cet algorithme ne peut s'écrire qu'avec les constructions tant que ou répéter.
Algorithme Syracuse

{ transforme n en n/2 si n est pair, en 3n+1 sinon. }
n entier valeur de la suite
cpt entier compteur nombre de tours
début
cpt <- 0
ecrire ('Valeur de départ (entier strictement positif) ?')
lire (n)
tant que n <> 1
si n mod 2 = 0
alors n <- n div 2
sinon n <- 3 n + 1
fin si
cpt <- cpt + 1
ecrire (n)
fin tant que
ecrire ('On doit appliquer',cpt,' fois la transformation avant d'arriver à 1.')
fin
Prev Up Next

Cours d'Informatique -- 6.3 Traitements de tableaux
Prev Up Next
Suivant : Exercices
6.3 Traitements de tableaux

Les traitements répétitifs peuvent s'appliquer à des informations en grande quantité. Par exemple la
calculette Francs Euros convertit tous les montants successivement saisis par l'utilisateur. Cependant, à
un moment donné, un seul - le dernier - de ces montants est mémorisé par l'ordinateur : en effet une seule
variable MontantEnFrancs est prévue pour le mémoriser. Le calcul effectué - la conversion en Euros - ne
dépend que du dernier montant saisi.
La notion de tableau apporte une réponse simple au problème de la mémorisation de toute une
"collection" d'informations : elles sont mémorisées "les unes à coté des autres". Cela permet alors de
programmer des traitements complexes où le résultat dépend de toutes les données. Les traitements de
tableaux peuvent être élémentaires - quand les traitements peuvent être effectués dans l'ordre où sont
rangées les informations - ou plus complexes, s'il convient de les consulter dans un ordre différent, ou de
les trier.
● Exemple introductif
● Définition
● Remplissage d'un tableau
● Traitement élémentaire et affichage
● Tri d'un tableau

Prev Up Next

Prev Up Next
Précédent : 6.3 Traitements de tableaux
Exercices
en annexe.
Exercice 6.11 : Manipulation d'un vecteur
Simuler le fonctionnement de l'algorithme suivant :
Algorithme ExempleVecteur
{ Sans commentaire }
Tab tableau[1..10] d'entiers
début
Tab[1] <- 10
tant que Tab[1] > 0
Tab[Tab[1]] <- Tab[1]
Tab[1] <- Tab[1] - 1
fin tant que
fin
Exercice 6.12 : Conversion d'un entier naturel en base 2
En reprenant la méthode de l'exercice de conversion d'un entier naturel en base 2, écrire un algorithme
qui effectue cette conversion et stocke le code en base 2 dans un vecteur. On pourra limiter ce vecteur à
32 composantes si on ne cherche à convertir que des entiers strictement inférieurs à 232.
Exercice 6.13 : Calcul de polynômes
On s'intéresse aux polynômes à coefficients réels de degré n que l'on note : P(x) = an xn + an-1xn-1+ ... +
a1 x + a0
Ecrire un algorithme demandant le degré du polynôme, puis ses coefficients, puis permettant à
l'utilisateur de calculer P(x) en autant de points x qu'il veut. On suppose que l'utilisateur saisit la valeur 0
pour x, pour indiquer qu'il souhaite arrêter les calculs.

Exercice 6.14 : Histogramme par intervalles

Pour analyser une série de mesures réelles strictement positives, dont on sait qu'elles sont comprises entre
0.0 et 10.0, on propose de les visualiser par un histogramme. L'histogramme représente les comptages
des mesures réparties dans les intervalles suivants : ]0,2], ]2,4] ...]8,10].
Ainsi, pour la série de mesures suivantes :
8.3 6.5 7.2 6.5 3.4 2.5 3.5 4.9
7.3 6.2 1.5 0.3 5.8 7.6 3.9 8.2
on désire afficher l'histogramme suivant.
]0,2] : **
]2,4] : ****
]4,6] : **
]6,8] : ******
]8,10] : **
Ecrire l'algorithme permettant d'effectuer ce traitement. On pourra, au choix, mémoriser ou non,
l'ensemble des mesures. On devra mémoriser les nombres de mesures appartenant à chaque intervalle.
Exercice 6.15 : Tri par extraction du maximum
Pour trier un tableau, il existe de nombreuses méthodes. Pour découvrir ou expérimenter des méthodes
systématiques - pouvant être décrites par un algorithme - on peut essayer à la main de trier un jeu de
cartes par exemple. Outre le tri par insertion déjà décrit, il est possible de :
● séparer les petites cartes d'un côté, les grandes de l'autre, puis trier chaque paquet séparément,
éventuellement en recommençant à séparer les plus petites des plus grandes.
● séparer en deux paquets au hasard, les trier chacun, puis fusionner les deux paquets en se servant
dans le bon paquet pour mettre l'ensemble des cartes dans l'ordre.
● parcourir le paquet à la recherche de la plus grande carte, la mettre à la fin du paquet, puis
recommencer à rechercher la plus grande du début du paquet; la mettre juste avant la plus grande
de toutes; recommencer jusqu'à ce que toutes les cartes aient été triées à la fin du paquet.
C'est cette dernière méthode dont on cherche à écrire l'algorithme. L'idée consiste :
● à rechercher le maximum parmi les composantes 1 à n et à mettre cette valeur en position n,
● à rechercher le maximum parmi les composantes 1 à n-1 et à mettre cette valeur en position n-1,
● à recommencer ainsi de suite, jusqu'à la dernière recherche, qui est celle du maximum entre les
composantes 1 et 2.
Prev Up Next

Prev Up
Exercice 6.11
Affectation [1] [2] [3] [4] [5] [6] [7] [8] [9] [10]
DEBUT
Exercice 6.12
Algorithme ConversionBase2
{ Conversion d'un entier naturel en base 2 }
n entier à convertir
i entier indice de parcours
code vecteur [0..31] d'entiers pour mémoriser le code
début
ecrire ('Entier naturel a convertir en base 2 ?')

lire (n)
pour i de 0 à 31
code[i] <- n mod 2
n <- n div 2
fin pour
ecrire ('le code en base 2 est :')

pour i de 31 à 0 par pas de -1
ecrire (code[i])
fin pour
fin
Exercice 6.13
L'algorithme doit mémoriser tous les coefficients du polynôme pour pouvoir effectuer les calculs. La saisie des coefficients se
fait en connaissant le nombre de coefficients à saisir (par le degré). Le calcul de P(x) est un calcul élémentaire, pouvant être
effectué coefficient par coefficient dans l'ordre où ils sont mémorisés. L'algorithme est alors le suivant :
Algorithme Polynome
{ remplit le tableau des coefficients réels d'un polynôme }
P tableau de 0 à 100 de réels on limite au degré 100
i entier indice pour parcourir le tableau

degre entier degré du polynome

x réel point saisi par l'utilisateur
Px réel valeur du polynôme P en x
début
ecrire ('Degré du polynome ?')

lire (degre)
pour i de 0 à degre
ecrire ('coefficient ', i)
lire (P[i])
fin pour { fin de la saisie du polynome }
ecrire ('x ? (0 pour terminer)') { lecture d'une valeur pour x }
lire ( x )
tant que x <> 0
Px <- 0 { calcul de P(x) }
pour i de 0 à degre
Px <- Px + P[i]*x^i
fin pour
ecrire ('P(', x, ') = ', Px) { affichage de P(x) }
ecrire ('x ? (0 pour terminer)') { lecture d'une autre valeur pour x }
lire ( x )
fin tant que
fin
Remarque : la partie "calcul de P(x)" n'est ni efficace, ni précise à cause des multiples calculs de puissance appliqués à x. Une
manière d'améliorer cela est d'utiliser la factorisation de Horner :
P(x) = a0 + x * (a1 + x * ( ...an-1+ x * (an)...))
Pour calculer P(x), il suffit alors de commencer par an, puis à chaque étape multiplier par x puis ajouter le coefficient de degré
inférieur. Le calcul se termine par l'ajout de a0.
Exercice 6.14
L'algorithme suivant permet de dessiner l'histogramme des mesures saisies.

Observer son comportement et répondre aux questions suivantes :
● les mesures saisies sont-elles mémorisées ?
● combien de caractères '*' sont imprimés ?
● comment faudrait-il modifier ce programme pour représenter un histogramme selon les intervalles : ]0,1], ]1,2] ...]9,10].
Algorithme histogramme
{ dessine l'histogramme des mesures saisies }
classe vecteur [1..5] d'entiers pour compter les mesures par classe
mesure réel une mesure saisie
i,j entiers compteurs de boucles
début

pour i de 1 à 5
classe[i]<- 0
fin pour
ecrire ('Mesure (0 pour terminer)')
lire (mesure)
tant que mesure > 0
si mesure <= 2 alors i <- 1
sinon si mesure <= 4 alors i <- 2
fin si
classe[i] <- classe[i] + 1
écrire('Mesure (0 pour terminer)')
lire(mesure)
fin tant que
pour i de 1 à 5
ecrire(']',2*(i-1),',',2*i,'] : ')
pour j de 1 à classe[i]
ecrire ('*')
fin pour
fin pour
fin
Exercice 6.15
Algorithme TriMaximum
{ trie un tableau, on suppose le tableau saisi (selon l'algorithme RemplissageTableau) et le nombre de valeurs connu }
TableauValeurs tableau de 1 à ... de ... tableau des valeurs saisies
max entier maximum d'une partie du tableau
indicemax entier indice indiquant la place du max
tmp entier variable temporaire pour échange
nombre entier nombre de valeurs saisies
fin entier tri entre 1 et fin, trié au delà
début
... { le tableau est saisi de 1 à nombre }

pour fin de nombre à 2 { reste à trier entre 1 et fin }
max <- TableauValeurs[1] { recherche du max entre 1 et fin }
indiceMax <- 1 { et de son indice : indiceMax }
pour i de 2 à fin
si TableauValeurs[i] > max
alors max <- TableauValeurs[i]
indiceMax <- i
fin si { fin recherche du max }

fin pour { echanger composantes max et fin }

temp <- TableauValeurs[fin] { le maximum est mis à la fin }
TableauValeurs[fin] <- TableauValeurs[indiceMax]
TableauValeurs[indiceMax] <- temp
fin pour { le tableau est trié en ordre croissant }
...
fin
L'exécution de cet algorithme sur le tableau :
85412
est la suivante (on note en abrégé TV pour TableauValeurs) :

Affectation TableauValeurs 1 2 3 4 5
tmp <- TV[5] 85412
TV[5]<- TV[1] 85418
TV[1] <- tmp 25418
tmp <- TV[4] 25418
TV[4]<- TV[2] 2 5 4 5 8
TV[2] <- tmp 2 1 4 5 8
tmp <- TV[3] 2 1 4 5 8
TV[3]<- TV[3] 2 1 4 5 8
TV[3] <- tmp 2 1 4 5 8
tmp <- TV[2] 2 1 4 5 8
TV[2]<- TV[1] 2 2 4 5 8
TV[1] <- tmp 1 2 4 5 8

Prev Up

Cours d'Informatique -- Exemple introductif
Up Next
Remonter : 6.1 Traitements conditionnels
Suivant : La construction conditionnelle
Exemple introductif
Dans l'algorithme suivant, qui résoud une équation du premier degré, il y a un problème si l'utilisateur
fournit un coefficient nul pour a. En effet, l'ordinateur effectue alors une division par 0, ce qui se traduit
en général par une erreur à l'exécution.
Algorithme EquationPremierDegre
{ Résoud une équation du premier degré, de type a x = b }
a réel le coefficient a, donné par l'utilisateur
b réel le coefficient b, donné par l'utilisateur
début
ecrire ('donnez les coefficients a et b')

lire (a)
lire (b)
ecrire ('la solution est ', b/a)
fin
Up Next

Cours d'Informatique -- La construction conditionnelle
Prev Up Next
Précédent : Exemple introductif
Suivant : La construction alternative
La construction conditionnelle
Définition : la construction conditionnelle permet de construire une instruction complexe de la forme :
...
si expression booléenne
alors instruction 1
instruction 2
...
fin si
...
dont le fonctionnement est le suivant :
● l'expression booléenne est tout d'abord calculée,
● puis les instructions comprises entre alors et fin si ne sont exécutées que si le résultat du
calcul donne vrai.
● puis la suite, s'il y en a une après fin si, est exécutée dans les 2 cas.
Ainsi, pour éviter le problème dans l'algorithme "Equation Premier Degré", on remplace la dernière
instruction par une instruction conditionnelle, pour indiquer que l'écriture n'est à effectuer que SI le
coefficient a est différent de 0.
...
si a <> 0
alors ecrire ('la solution est ', b/a)
fin si
...
Pour executer la traduction de cet algorithme en JavaScript

Prev Up Next

Cours d'Informatique -- La construction alternative
Prev Up Next
Précédent : La construction conditionnelle
Suivant : Composition de ces constructions
La construction alternative
Définition : La construction alternative permet de construire une instruction complexe de la forme :
...
si expression booléenne
alors instruction 1
instruction 2
...
sinon instruction 1'
instruction 2'
...
fin si
...
● l'expression booléenne est tout d'abord calculée,
● si le résultat du calcul donne vrai, les instructions 1, 2 ...sont exécutées,
● si le résultat du calcul donne faux, les instructions 1', 2' ...sont exécutées,
● puis la suite, s'il y en a une après fin si, est exécutée dans les 2 cas.
L'algorithme "Equation Premier Degré", peut alors être amélioré ainsi, pour afficher un message quand le
coefficient a est nul.
...
si a <> 0
sinon ecrire ('je ne sais pas faire')
fin si
...

Prev Up Next

Cours d'Informatique -- Composition de ces constructions
Prev Up Next
Précédent : La construction alternative
Suivant : Utilisation d'opérations booléennes
Composition de ces constructions

Pour résoudre un problème complexe, un algorithme peut devenir complexe. Chacune des instructions le
composant - y compris celles figurant dans une construction conditionnelle ou alternative - peut être
remplacée par une construction conditionnelle ou alternative.
On peut obtenir alors un algorithme en forme de "poupée russe", où les constructions sont emboitées les
unes dans les autres.
L'algorithme "Equation Premier Degré", peut encore être amélioré - avec l'aide d'un mathématicien -
pour distinguer les cas en fonction du coefficient b. La nouvelle partie de l'algorithme (en gras) n'est
exécutée que si a est nul. L'affichage de Tout x est solution a lieu si de plus b est nul. L'affichage de Pas
de solution a lieu dans le cas contraire.
...
si a <> 0
sinon si b = 0
alors ecrire ('Tout x est solution')
sinon ecrire ('Pas de solution')
fin si
fin si
...
Pour qu'un algorithme soit lisible - pour voir au premier coup d'oeil comment les instructions sont
"emboitées" - on a décalé vers la droite l'écriture de l'ensemble de la construction en gras. Cette méthode
de mise en page, appelée "indentation" doit être utilisée systématiquement dans l'écriture d'algorithmes
(ou de programmes).
Prev Up Next

Cours d'Informatique -- Utilisation d'opérations booléennes
Prev Up Next
Précédent : Composition de ces constructions
Suivant : Quelques équivalences entre constructions
Utilisation d'opérations booléennes

On peut donner une solution équivalente à la précédente, en écrivant en séquence, plusieurs instructions
conditionnelles, chargée chacune d'écrire le message approprié pour 1 des 3 cas envisagés.
On utilise ici l'opération booléenne et dont le résultat n'est vrai que si ses deux opérandes ont pour
résultat vrai.
...
si a <> 0
fin si
si a = 0 et b = 0
alors ecrire ('Tout x est solution')
fin si
si a = 0 et b <> 0
alors ecrire ('Pas de solution')
fin si
...
Dans cette version de l'algorithme "Equation Premier Degré" les trois instructions conditionnelles sont
exécutées l'une après l'autre. Mais dans chacune d'entre elles, l'instruction d'écriture n'est exécutée que si
la condition correspondante donne le résultat vrai.
Pour se convaincre, que cette solution est bien équivalente à la précédente, on peut observer que parmi
les 3 conditions, une et une seule des trois peut être vraie. Ainsi quel que soit les données fournies, un et
un seul des trois messages s'affichera (reste à vérifier que c'est le bon message).
Les tableaux suivants détaillent le résultat des 3 conditions en fonction des cas : a=0, a<>0 croisés avec
les cas : b=0, b<>0.
a<>0
b=0 b<>0
a=0 faux faux
a<>0 vrai vrai
a=0 et b=0

Cours d'Informatique -- Utilisation d'opérations booléennes
b=0 b<>0
a=0 vrai faux
a<>0 faux faux
a=0 et b<>0
b=0 b<>0
a=0 faux vrai
a<>0 faux faux
Remarque: de tels tableaux, couramment utilisés en informatique sont appelés "tables de vérité".
Prev Up Next

Cours d'Informatique -- Quelques équivalences entre constructions
Prev Up Next
Précédent : Utilisation d'opérations booléennes
Suivant : Choix selon des valeurs énumérées
Quelques équivalences entre constructions

Les deux solutions précédentes illustrent une situation quasi-générale en informatique, et plus particulièrement dans l'écriture
d'algorithmes.
On peut proposer plusieurs solutions "équivalentes" à un même problème, sans que l'une puisse être qualifiée de "meilleure"
que l'autre. On dit ici que deux algorithmes sont équivalents, si quand on leur fournit les mêmes données, ils fournissent
toujours les mêmes résultats.
Les constructions conditionnelles alliées aux opérations booléennes sont une source de quantité de variations possibles dans
l'écriture d'algorithmes.
Par exemple les schémas d'algorithmes suivants sont équivalents 2 par 2 quelles que soient les expressions booléennes (notées
conditions) et les instructions qu'ils contiennent (à condition toutefois qu'expressions et instructions s'exécutent sans erreur !).
L'opération et donne un résultat vrai si et seulement si ses deux opérandes donnent un résultat vrai.
si condition1 si condition1 et condition2

alors si condition2 alors instruction
alors instruction fin si
fin si
fin si
L'opération ou donne un résultat vrai si et seulement si l'une des deux opérandes ou les deux donnent un résultat vrai.
si condition1 si condition1 ou condition2

alors instruction alors instruction
sinon si condition2 fin si
alors instruction
fin si
fin si { L'instruction du schéma de gauche est la même répétée 2 fois. }
L'opération non donne un résultat vrai si et seulement si son opérande donne un résultat faux.
si condition si non condition

alors instruction1 alors instruction2
sinon instruction2 sinon instruction1
fin si fin si
Prev Up Next

Cours d'Informatique -- Choix selon des valeurs énumérées
Prev Up Next
Précédent : Quelques équivalences entre constructions
Choix selon des valeurs énumérées

Cette dernière construction diffère des précédentes, car elle ne fait pas usage d'expression booléenne.
On l'utilise quand, en fonction d'une seule donnée, on souhaite effectuer un et un seul traitement parmi
une série de traitements possibles.
Définition : La construction de choix permet de construire une instruction complexe de la forme :
...
selon expression
valeur1 : instruction 1.1
instruction 1.2
...
valeur2 : instruction 2.1
instruction 2.2
...
...
autrement : instruction n.1
instruction n.2
...
fin selon
...
● l'expression est tout d'abord calculée, elle doit avoir un résultat de type "énumérable", c'est-à-dire
dont on peut énumérer les valeurs : en pratique de type entier ou caractère,
● si le résultat du calcul donne une des valeurs prévues, alors les instructions correspondantes sont
exécutées,
● si le résultat du calcul donne une valeur qui n'était pas prévue, les instructions associées au cas
autrement sont exécutées. Le cas autrement est facultatif.
Cette construction est pratique pour la partie d'algorithme suivante, dans laquelle on suppose que la
variable jour contient un entier - compris entre 1 et 7 - représentant le jour de la semaine (du lundi au
dimanche). L'algorithme affiche en toutes lettres le nom du jour correspondant.
...
selon jour
1 : ecrire('Lundi')

Cours d'Informatique -- Choix selon des valeurs énumérées
2 : ecrire('Mardi')
3 : ecrire('Mercredi')
4 : ecrire('Jeudi')
5 : ecrire('Vendredi')
6 : ecrire('Samedi')
7 : ecrire('Dimanche')
autrement : ecrire('Erreur')
fin selon
...
Il est possible d'écrire un algorithme équivalent en utilisant des constructions alternatives, mais ceci est
quelque peu fastidieux.
...
si jour=1
alors ecrire('Lundi')
sinon si jour=2
alors ecrire('Mardi')
sinon si jour=3
alors ecrire('Mercredi')
sinon si jour=4
alors ecrire('Jeudi')
sinon si jour=5
alors ecrire('Vendredi')
sinon si jour=6
alors ecrire('Samedi')
sinon si jour=7
alors ecrire('Dimanche')
sinon ecrire('Erreur')
fin si
fin si
fin si
fin si
fin si
fin si
fin si
...
Il est d'ailleurs toujours possible de remplacer une construction selon par une série de constructions si
alors sinon imbriquées.
On conviendra cependant facilement à la vue de cet exemple, que la construction selon, permet un
raccourci évident d'écriture, quand cette construction peut être utilisée.
Prev Up Next

Prev Up
Précédent : Choix selon des valeurs énumérées

Les constructions conditionnelle (si alors) et alternative (si alors sinon) ont une traduction
directe en Pascal :
if expression
then instruction
if expression
then instruction
else instruction
et en JavaScript :
if ( Expression )
Instruction
if ( Expression )
Instruction
else Instruction
Pour écrire une séquence d'instruction à l'intérieur d'un des cas au lieu d'une seule instruction telle qu'il
est indiqué dans les formes ci-dessus, il faut "emballer" la séquence d'instructions dans un bloc, pour
qu'elle ne fasse plus qu'une seule instruction.
Ceci se note de la manière suivante en Pascal :
begin
sequence
end
et en JavaScript :
{
Sequence
}
La construction de choix selon des valeurs énumérées (selon) a des traductions particulières dans
chacun des langages étudiés. En Pascal, la traduction est assez directe :
case expression of
liste de constantes : instruction ;

...
liste de constantes : instruction ;
[ otherwise instruction ]
end
En JavaScript, pour obtenir un comportement équivalent, il suffit de combiner l'instruction switch, avec
des instructions break :
switch ( Expression ) {
case Constante : Instruction ; break;
...
case Constante : Instruction ; break;
[ default : Instruction ]
}
Attention, si l'on omet l'instruction break, après exécution du cas choisi, les instructions des cas suivants
sont exécutées en séquence.
Prev Up

Cours d'Informatique -- La construction : Tant que
Up Next
Remonter : 6.2 Traitements répétitifs
Suivant : La construction : Répéter
La construction : Tant que

Définition : tant que permet de construire une instruction complexe de la forme :
...
tant que expression booléenne
instruction 1
instruction 2
...
fin tant que
...
1. l'expression booléenne est tout d'abord calculée,
2. si le calcul de l'expression booléenne donne vrai, les instructions comprises entre tant que et fin
tant que sont exécutées,
3. puis l'exécution recommence au point 1,
4. la suite, s'il y en a une après fin tant que, est exécutée dès que le calcul de l'expression booléenne,
effectué au point 1, donne faux.
Application
Utilisons cette construction pour résoudre le problème du calcul du nombre d'années nécessaire pour doubler son
épargne. On affiche aussi au fur et à mesure des calculs, l'épargne constituée année après année.
Algorithme Epargne
{ Calcule le nombre d'années nécessaire pour doubler son épargne }
Montant réel le montant de l'épargne
NombreAnnees entier le résultat cherché
début
Montant <- 1000

NombreAnnees <- 0
tant que Montant < 2000
ecrire ('Montant : ', Montant, ' dans ', NombreAnnees, ' an(s)')
Montant <- Montant * 1,0825
NombreAnnees <- NombreAnnees + 1
fin tant que
ecrire ('Montant final: ', Montant, ' dans ', NombreAnnees, ' an(s)')

Cours d'Informatique -- La construction : Tant que
fin
L'exécution de cet algorithme donne le résultat suivant :
Montant : 1000.00 dans 0 an(s)

Montant final: 2041.04 dans 9 an(s)
On constate que les 3 instructions contenues dans la construction tant que sont exécutées 9 fois. Leur dernière
exécution commence avec Montant=1885.49 et se termine avec Montant= 2041.04. La condition Montant < 2000
est alors fausse; L'instruction suivant la construction tant que est donc exécutée, provoquant l'affichage de :
Montant final: 2041.04 dans 9 an(s).
Remarques
L'expression booléenne d'une construction tant que doit pouvoir être calculée dès le début de la construction :
les variables qui apparaissent dans l'expression doivent donc toutes avoir une valeur avant.
Les instructions contenues dans la construction tant que peuvent ne jamais être exécutées, si dès la première
fois, l'expression booléenne a la valeur faux.
Les instructions contenues dans la construction tant que doivent contribuer à modifier le calcul de l'expression
booléenne, pour que ce calcul finisse par donner la valeur faux. L'expression booléenne d'une construction tant
que est aussi appelée "condition de continuation".
Up Next

Cours d'Informatique -- La construction : Répéter
Prev Up Next
Précédent : La construction : Tant que
Suivant : La construction : Pour
La construction : Répéter
Définition : la construction répéter...jusqu'à permet de construire une instruction complexe de la forme :
répéter
instruction 1
instruction 2
...
jusqu'à expression booléenne
1. les instructions comprises entre répéter et jusqu'à sont exécutées
2. l'expression booléenne est alors calculée,
3. si le calcul de l'expression booléenne donne faux, l'exécution recommence au point 1; si le calcul de
l'expression booléenne donne vrai, l'exécution continue avec la suite, s'il y en a une après jusqu'à.
Application
Utilisons cette construction pour le calcul d'épargne.
Algorithme EpargneBis
{ Calcule le nombre d'années nécessaire pour doubler son épargne }
NombreAnnees entier le résultat cherché
début
Montant <- 1000

NombreAnnees <- 0
répéter
NombreAnnees <- NombreAnnees + 1
jusqu'à Montant >= 2000
ecrire ('Montant final: ', Montant, ' dans ', NombreAnnees, ' an(s)')
fin
L'exécution de cet algorithme donne le résultat suivant (même résultat que la solution avec tant que):

Cours d'Informatique -- La construction : Répéter

Montant final: 2041.04 dans 9 an(s)
Les 3 instructions contenues dans la construction répéter sont exécutées 9 fois. Leur dernière exécution
commence avec Montant=1885.49 et se termine avec Montant= 2041.04. La condition Montant >= 2000 a alors la
valeur vrai; L'instruction suivant la construction répéter est alors exécutée, provoquant l'affichage de :
Montant final: 2041.04 dans 9 an(s).
Remarques
L'expression booléenne d'une construction répéter n'a besoin d'être calculée, pour la première fois, qu'après
une première exécution des instructions contenues dans la construction répéter.
Les instructions contenues dans la construction répéter sont toujours exécutées au moins une fois.
Les instructions contenues dans la construction répéter doivent contribuer à modifier le calcul de l'expression
booléenne, pour que ce calcul finisse par donner la valeur vrai. L'expression booléenne d'une construction
répéter est aussi appelée "condition d'arrêt".
Prev Up Next

Cours d'Informatique -- La construction : Pour
Prev Up Next
Précédent : La construction : Répéter
Suivant : Exemples de traitements répétitifs
La construction : Pour
A la différence des deux constructions précédentes, la construction pour est destinée au cas particulier où l'on
connaît par avance le nombre de fois où l'on veut répéter certains traitements. C'est le cas si, dans l'exemple du
calcul de l'épargne, on souhaite seulement imprimer le montant du placement pour les 5 années à venir.
La construction pour permet de répéter n fois un traitement ; elle permet de plus de faire évoluer une variable
(appelée "compteur"), en lui affectant pour chacune des exécutions une nouvelle valeur (augmentée de 1 à
chaque fois).
Définition : la construction pour permet de construire une instruction complexe de la forme :
...
pour compteur de valeurdebut à valeurfin
instruction 1
instruction 2
...
fin pour
...
1. les instructions comprises entre pour et fin pour sont exécutées une première fois, avec la variable
compteur valant valeurdebut
2. ces instructions sont réexécutées, avec la variable compteur valant valeurdebut+1
3. ...
4. les instructions sont exécutées une dernière fois, avec la variable compteur valant valeurfin
5. les instructions suivant la construction pour sont exécutées ensuite.
Les instructions sont exécutées autant de fois qu'il y a d'entiers entre valeurdebut et valeurfin : c'est-à-dire en
particulier 1 fois si valeurdebut=valeurfin, 0 fois si valeurdebut>valeurfin.
Application
Le calcul de l'épargne obtenue pour les 5 prochaines années s'écrit alors ainsi :
Algorithme EpargneTer
{ Affiche l'épargne des 5 prochaines années }
NombreAnnees entier le compteur

début
Montant <- 1000

pour NombreAnnees de 1 à 5
fin pour
fin
L'exécution de cet algorithme donne le résultat suivant :

Remarques
La variable "compteur" ne doit pas être modifiée par les instructions contenues dans la construction pour ; sa
valeur ne peut qu'être utilisée et ceci uniquement à l'intérieur des instructions contenues dans la construction
pour.
A la différence des algorithmes précédents utilisant tant que et répéter, il aurait été possible d'écrire -
plus longuement - cet algorithme en recopiant 5 fois les instructions nécessaires :
Montant <- 1000

ecrire ('Montant : ', Montant, ' dans ', 1 , ' an(s)')
Evidemment cette solution, équivalente à la solution avec pour n'a d'intérêt que pour illustrer le
comportement de la construction pour.
Equivalence Pour/Tant que
On peut considérer la construction pour comme un raccourci d'écriture d'un traitement répétitif avec tant
que augmentant la valeur d'un compteur utilisé pour fixer le nombre d'itérations. En effet le schéma
d'algorithme suivant :

pour compteur de valeurdebut à valeurfin

instruction 1
instruction 2
...
fin pour
est équivalent au schéma suivant avec tant que :
compteur <- valeurdebut

tant que compteur <= valeurfin
instruction 1
instruction 2
...
compteur <- compteur + 1
fin tant que
Prev Up Next

Cours d'Informatique -- Exemples de traitements répétitifs
Prev Up Next
Précédent : La construction : Pour
Exemples de traitements répétitifs

L'exemple utilisé en introduction, est un traitement où l'affichage (des montants épargnés chaque année) est
effectué de manière répétitive. Cet exemple montre explicitement la répétition car une ligne est affichée à
chaque étape. Cependant l'utilisation de constructions répétitives (répéter, tant que ou pour) est
beaucoup plus générale que cela : selon les besoins, ces constructions pourront être utilisées pour répéter des
interactions avec l'utilisateur ou des calculs complexes, pouvant eux-mêmes être composés de constructions
séquentielles, conditionnelles ou répétitives.
Contrôle de saisie :
L'exemple le plus simple d'interaction répétée est un programme de saisie d'une valeur devant respecter une
condition donnée. Par exemple, le programme d'un distributeur de billet redemande le code tant que l'usager
de la carte donne un code erroné, demande un montant de retrait jusqu'à ce que ce montant soit "correct".
L'algorithme suivant demande un montant jusqu'à ce que le montant saisi soit un entier positif multiple de
100 compris entre 100 et 1800.
répéter
ecrire('Montant du retrait: 100 à 1800 F')
lire (Montant)
jusqu'à Montant mod 100 = 0 et Montant >= 100 et Montant <= 1800
ecrire('Retrait de : ', Montant, ' F accepté')
Calculette Francs Euros
L'algorithme de conversion de francs en euros peut être modifié ainsi pour effectuer des conversions de
francs en euros, tant que l'utilisateur tape un montant en francs strictement positif.
Algorithme CalculetteEuro
{ calculette Francs Euros }
MontantEnFrancs réel une variable pour les montants successifs en francs
début
ecrire ('Donner un montant en Francs (0 pour finir)')


Cours d'Informatique -- Exemples de traitements répétitifs
tant que MontantEnFrancs <> 0

ecrire ('La valeur en Euros est : ', MontantEnFrancs / 6.55957)
ecrire ('Donner un montant en Francs ')
fin tant que
ecrire ('Au revoir')
fin
Calcul itératif
On cherche à calculer une approximation de la limite de la série Sigmai=0N(1/i!). Pour calculer les termes
successifs et les ajouter on utilise une répétition. L'algorithme est alors le suivant :
Algorithme E
{ calcul itératif }
X réel calcul de la somme 1/0! + 1/1! + 1/2! ... + 1/N!
T réel T sert à calculer i!= i*(i-1)* ... 1
i,N entier indice, nombre d'itérations
début
ecrire('Nombre d'iterations ? ')

lire (N)
X <- 1 T <- 1
pour i de 1 à N
T <- T * i
X <- X + (1/T)
fin pour
ecrire ('Approximation de E: ', X)
fin

Prev Up Next

Prev Up
Précédent : Exemples de traitements répétitifs

La construction tant que a une traduction directe en Pascal :
while expression
do instruction
et en JavaScript :
while ( Expression )
Instruction
La construction répéter a une traduction directe en Pascal :

repeat
sequence
until expression
En JavaScript, il existe une construction hybride entre répéter et tant que qui a la forme suivante :
do
Instruction
while ( Expression )
Le test est bien effectué aprés l'exécution de l'instruction (comme dans la construction répéter), mais
c'est un test de continuation (comme dans la construction tant que) au lieu d'un test d'arrêt.
La construction pour a une traduction directe en Pascal :
for variable := expression to expression do
instruction
et une variante permettant de faire diminuer la variable de 1 à chaque itération :

for variable := expression downto expression do
instruction
En JavaScript, la traduction de la construction pour est possible, par une instruction plus générale :
for ( Affectation ; Expression ; Affectation )
Instruction
que l'on peut adapter ainsi :

for ( Variable = Expression 1 ; Variable <= Expression 2 ; Variable = Variable + 1 )

Instruction
Cette instruction est alors la traduction de :
pour Variable de Expression1 à Expression2

Instruction
fin pour
Prev Up

Up Next
Remonter : 6.3 Traitements de tableaux
Suivant : Définition
Exemple introductif
L'algorithme de calcul de la moyenne n'utilise qu'une variable Mesure dans laquelle sont mémorisées sucessivement les
mesures saisies. Cela est possible car les seules informations, à mémoriser pour calculer la moyenne des mesures, sont leur
somme et leur nombre. Si on voulait calculer le nombre de mesures inférieures à la moyenne et le nombre de mesures
supérieures, il faudrait alors mémoriser toutes les mesures, calculer leur moyenne, puis compter, mesure par mesure, celles
qui sont inférieures ou supérieures à la moyenne.
L'algorithme de calcul de la moyenne avec mémorisation des mesures dans un tableau s'écrit :
Algorithme MoyenneTableau
{ Compte et calcule la moyenne d'une série de mesures }
Nombre entier nombre de mesures
Mesure réel mesure saisie
TableauMesures tableau de 1 à 100 de réels tableau des mesures saisies
Somme réel somme des mesures
Moyenne réel Le résultat à calculer
début
Nombre <- 0 { Les variables Nombre et Somme }

Somme <- 0 { sont nulles avant la saisie }
lire (Mesure)
tant que Mesure > 0
Nombre <- Nombre + 1 { on ne compte que les mesures positives }
Somme <- Somme + Mesure { et surtout pas la derniere valeur }
TableauMesures [Nombre] <- Mesure { stocke la mesure à son rang: }
ecrire ('Mesure?(négatif pour finir)') { la 1ere en position 1 }
lire (Mesure) { la 2nde en position 2 ... }
fin tant que
Moyenne <- Somme / Nombre
écrire ('Nombre de mesures =', Nombre)
écrire ('Moyenne des mesures =', Moyenne)
...
fin
Pour mémoriser toutes les mesures dans un tableau, on doit d'abord faire une hypothèse sur leur nombre maximal. On
suppose qu'il y en aura au plus 100. On utilise alors une variable TableauMesures, qui peut contenir 100 nombres réels,
chacun étant numéroté par un indice pouvant varier de 1 à 100.
Une mesure particulière, la 10e par exemple, est notée : TableauMesures[10].
Après l'exécution de cet algorithme, les mesures saisies sont stockées dans les variables :

TableauMesures[1], TableauMesures[2], TableauMesures[3]...Il ne reste plus qu'à consulter l'ensemble de ces variables
pour faire les calculs souhaités.
Up Next

Cours d'Informatique -- Définition
Prev Up Next
Précédent : Exemple introductif
Suivant : Remplissage d'un tableau
Définition
Tableau : On appelle tableau une collection d'informations de même type, chacune étant repérée par un indice.
Déclarer une variable en tant que tableau, revient à déclarer une collection de variables, toutes du même type, chaque
composante étant repérée par son indice. Pour déclarer une variable en tant que tableau, il faut donner le type de ses
composantes et le nombre de composantes ou les valeurs possibles de l'indice.
Les tableaux peuvent être de dimension 1 - on parle alors aussi de vecteurs - de dimension 2, ou plus. L'indice d'une
composante est formé, selon la dimension, de 1 entier , 2 entiers ou plus.
Notations: Soit T une variable tableau de nombres réels, indexé par un indice variant de 1 à 100, la ième composante de ce
tableau est notée : T[i]. Soit Image une variable tableau de booléens, à 2 dimensions indexé par 2 indices variant de 1 à 1024, la
jème composante de la ieme ligne de ce tableau est notée : T[i,j].
Manipulation des composantes d'un tableau
L'utilisation d'un tableau se fait toujours composante par composante. Les instructions suivantes sont correctes, si T est un
tableau de réels dont l'indice varie de 1 à 100 :
lire (T[1]) { range la valeur saisie dans la 1ere composante }

T[2] <- 3.5 { mémorise le réel 3.5 dans la seconde }
T[3] <- T[2] * 4.28 { calcule la troisième composante }
ecrire (T[3]) { écrit le réel contenu dans la 3eme composante }
pour i de 5 à 100 { calcule les valeurs des composantes }
T[i] <- i * 3.14 { d'indice compris entre 5 et 100 }
fin pour
La règle pour savoir comment utiliser une composante d'un tableau est la suivante :
Soit T un tableau de deb à fin d'informations de type P, on peut écrire T[i] à un endroit d'un programme, si et seulement si :
i est compris entre deb et fin
et si on peut écrire : x, au même endroit de ce programme, x étant une variable de type P.
Déclaration d'un tableau
La déclaration d'une variable tableau dans un algorithme peut être considérée comme un raccourci d'écriture. En effet, la
déclaration de : T: tableau de 1 à 100 de réels est beaucoup plus concise que la déclaration de 100 variables : T1, T2, T3, ...
T100 : réels. Les deux permettent cependant de mémoriser exactement les mêmes informations.
L'instruction (pour) (voir exemple ci-dessus) montre l'intérêt d'un tableau par rapport à 100 variables distinctes : elle rend
possible, l'affectation de toutes les composantes d'un tableau par une seule construction répétitive, alors qu'il aurait fallu écrire
autrement autant d'affectations que de variables à affecter.
Prev Up Next

Cours d'Informatique -- Remplissage d'un tableau
Prev Up Next
Précédent : Définition
Suivant : Traitement élémentaire et affichage
Remplissage d'un tableau

Dans l'exemple introductif, le remplissage du tableau permet de mémoriser simultanément un nombre
quelconque de mesures saisies - on n'en connaît pas le nombre à l'avance - à condition que ce nombre ne
dépasse pas la taille prévue pour le tableau.
L'algorithme de remplissage utilisé - en faisant abstraction des calculs - est d'usage général, et pourra
souvent être réutilisé tel quel :
Algorithme RemplissageTableau
{ remplit un tableau avec des valeurs saisies, la fin est signalée par la valeur FIN }
Valeur à préciser valeur saisie
FIN même type que Valeur Constante signalant la fin
nombre entier pour parcourir le tableau et compter
début
nombre <- 0
ecrire ('Valeur ? (FIN pour finir)')
lire (Valeur)
tant que Valeur <> FIN
nombre <- nombre + 1
TableauValeurs [nombre] <- Valeur
ecrire ('Valeur ? (FIN pour finir)')
lire (Valeur)
fin tant que
écrire ('Nombre de valeurs enregistrees =', nombre)
...
fin
Dans le cas, où l'utilisateur préfère compter d'abord les valeurs à saisir, avant de les saisir, on peut
modifier l'algorithme de remplissage du tableau. En effet l'utilisateur peut alors indiquer le nombre de
valeurs à saisir. L'algorithme peut donc prévoir le nombre de fois où il faut répéter la lecture d'une
valeur, et ne nécessite plus l'usage d'une valeur particulière pour indiquer la fin de la saisie. On obtient

Cours d'Informatique -- Remplissage d'un tableau
ainsi, le schéma d'algorithme suivant, utilisable pour remplir un tableau avec un nombre de valeurs
déterminé à l'avance :
Algorithme RemplissageTableauNombreConnu
{ remplit un tableau avec des valeurs saisies, le nombre des valeurs est connu avant la saisie }
nombre entier nombre de valeurs à saisir
début
ecrire ('Nombre de valeurs ?')

lire (nombre)
pour i de 1 à nombre
ecrire ('Valeur ?')
lire (TableauValeurs [i])
fin pour
...
fin
Cet algorithme est plus simple d'écriture, mais il laisse une partie du travail - le comptage des valeurs - à
l'utilisateur.
Prev Up Next

Cours d'Informatique -- Traitement élémentaire et affichage
Prev Up Next
Précédent : Remplissage d'un tableau
Suivant : Tri d'un tableau
Traitement élémentaire et affichage

Les traitements les plus élémentaires que l'on effectue sur un tableau sont ceux où le traitement peut s'effectuer
composante par composante, dans l'ordre où elles sont rangées dans le tableau.
C'est le cas, pour l'algorithme de calcul de la moyenne, quand on cherche à lui rajouter le comptage des nombres de
mesures inférieures (et supérieures ou égales) à la moyenne. Ceci peut se faire en le complétant de la façon suivante :
Algorithme InfSupMoyenne
{ Complète l'algorithme MoyenneTableau }
...
NombreInf entier nombre de mesures inférieures à la moyenne
début
...
NombreInf <- 0
pour i de 1 à Nombre
si TableauMesures[i] < Moyenne alors NombreInf <- NombreInf + 1
fin pour
écrire ('Nombre de mesures inférieures:', NombreInf)
écrire ('Nombre de mesures supérieures ou égales:', Nombre - NombreInf)
fin
Pour compter le nombre de mesures inférieures à la moyenne, on répète pour chacune des mesures mémorisées dans le
tableau, la comparaison avec la moyenne, suivie le cas échéant de l'incrémentation du nombre de valeurs inférieures.
L'affichage d'un tableau fait partie des "traitements élémentaires" les plus usuels. Il se fait composante par composante,
selon l'algorithme suivant :
Algorithme AffichageTableau
{ Complète l'algorithme RemplissageTableau }
début

Cours d'Informatique -- Traitement élémentaire et affichage
... { Remplissage du tableau }

pour i de 1 à nombre
ecrire (TableauValeurs [i]) { Afficahge du tableau }
fin pour
fin
Les traitements élémentaires, et les affichages, peuvent généralement être programmés selon les schémas ci-dessus (avec
la construction pour) : en effet le nombre d'éléments d'un tableau, même s'il n'est pas connu avant la saisie peut toujours
l'être, après la saisie, quand il faut traiter ou afficher les éléments du tableau.
Prev Up Next

Cours d'Informatique -- Tri d'un tableau
Prev Up Next
Précédent : Traitement élémentaire et affichage
Tri d'un tableau

Dès lors que le traitement à effectuer sur un tableau est plus complexe, il nécessite de consulter les éléments dans un ordre
particulier ou de consulter plusieurs fois chaque élément.
Il faut alors envisager selon le cas, soit d'écrire un algorithme adapté au problème, soit de commencer par effectuer un tri
des éléments du tableau.
Tri : Trier un tableau selon une relation d'ordre entre ses éléments, consiste à modifier le tableau en échangeant les
positions de ses éléments, de telle sorte que tous les éléments soient conservés, et qu'ils soient rangés dans l'ordre demandé.
On peut trier des tableaux de nombres (entiers ou réels) en ordre croissant ou décroissant, des tableaux de chaînes de
caractères, selon l'ordre alphabétique (souvent basé sur l'ordre des caractères fourni par leur codage)....
De nombreux algorithmes existent pour trier des tableaux. Un des plus simples - mais pas des plus efficaces - est le tri dit
"par insertion". Son principe est le suivant : on prend un élément ; on en prend un second que l'on positionne avant ou après
le premier selon sa valeur ; on en prend un troisième que l'on insère à la bonne place par rapport aux 2 premiers; on continue
ainsi tant qu'il y a des éléments à trier dans le tableau. Cette technique est la plus utilisée pour trier un jeu de cartes à la main
par exemple.
Cet algorithme peut s'écrire avec un tableau et une variable intermédiaire destinée à mémoriser l'élément à insérer, en
rangeant les éléments triés au fur et à mesure dans le tableau à trier. Cela nécessite alors parfois de décaler des éléments
pour faire une place pour l'élément à insérer.
Algorithme TriTableau
{ trie un tableau, on suppose le tableau saisi (selon l'algorithme RemplissageTableau) et le nombre de valeurs connu }
Ainserer ... valeur à insérer
place entier indice indiquant la place où insérer
début
... { saisie d'un tableau non trié }

pour i de 2 à nombre { le tableau est supposé trié entre les }
Ainserer <- TableauValeurs[i] { indices 1 et i-1 }
{ il faut insérer le ieme à sa place }
place <- i { sa place actuelle est i }
tant que non (place=1 ou TableauValeurs[place-1]<= Ainserer)
{ ce n'est pas la bonne place, décaler }
TableauValeurs[place] <- TableauValeurs[place-1]
place <- place-1 { est-ce la précédente ? }
fin tant que { les plus grands sont décalés }

Cours d'Informatique -- Tri d'un tableau
TableauValeurs[place] <- Ainserer { la place est libre }

fin pour
... { le tableau est trié, à afficher }
fin
L'exécution de cet algorithme sur le tableau :
85412
est la suivante (on note en abrégé TV pour TableauValeurs) :

Affectation TableauValeurs 1 2 3 4 5 Ainserer
Ainserer <- TV[2] 8 412 5
TV[2] <- TV[1] 8412 5
TV[1] <- Ainserer 58412
TV[3] <- TV[2] 5 812 4
TV[2] <- TV[1] 5812 4
TV[4] <- TV[3] 45 82 1
TV[3] <- TV[2] 4 582 1
TV[2] <- TV[1] 4582 1
Ainserer <- TV[5] 1458 2
TV[5] <- TV[4] 145 8 2
TV[4] <- TV[3] 14 58 2
TV[3] <- TV[2] 1 458 2
Les cases laissées en blanc, ont des valeurs dont on n'a pas besoin pour la suite de l'algorithme (c'est pour cela qu'elles ne
sont pas notées) : ce sont les composantes où l'on peut ranger l'élément à insérer sans risque de perdre un élément du
tableau.
Prev Up Next

Prev Up
Précédent : Tri d'un tableau

Pour déclarer un tableau en Pascal, la solution la plus élégante consiste à définir le type de ce tableau, ce
qui permet par la suite de déclarer des variables de ce type tableau.
La définition d'un type tableau a la forme suivante :
type nom = array[ constante .. constante ]of type ;
Les deux constantes à fournir sont les indices du premier et du dernier élément. Le type est celui de tous
les éléments du tableau.
Un élément d'un tableau est désigné par une expression de la forme :
variable [ expression ]
Cette même notation sert à la fois pour accéder ou pour modifier un élément d'un tableau.
En JavaScript, la déclaration d'un tableau se fait en donnant uniquement le nombre d'éléments de ce
tableau. Les éléments ont alors des indices variant de 0 à n - 1, où n est le nombre d'éléments.
var Nom = new Array ( Constante )
Un élément d'un tableau est noté en JavaScript (comme en Pascal) par une expression de la forme :
Variable [ Expression ]

Prev Up

Cours d'Informatique -- 8 Pour aller plus loin
Prev Up Next
Précédent : 7 Pour bien programmer
Remonter : Top
Suivant : 9 En conclusion
8 Pour aller plus loin

Les premiers chapitres de ce cours ont donné une initiation générale à l'informatique, en tant que science
et techniques de traitement de l'information. Les chapitres suivants ont concentré l'attention sur la
conception d'algorithmes et de programmes.
Ce savoir-faire occupe une position centrale en informatique. C'est un pré-requis qui permet d'étudier
ensuite les problèmes particuliers posés par chacun de ses domaines d'application.
La conception d'algorithmes est un préalable nécessaire à la programmation quel que soit le langage de
programmation - il en existe de nombreux - utilisé.
Une étude plus approfondie de l'informatique, nécessite par ailleurs la compréhension des théories
fondamentales, sur lesquelles reposent la discipline.
● 8.1 Domaines d'application de l'informatique
● 8.2 La tour de Babel
● 8.3 Théories fondamentales

Prev Up Next

Up
Remonter : 7 Pour bien programmer
Exemple introductif
On cherche à écrire un programme permettant à l'utilisateur de proposer des nombres entiers positifs
jusqu'à ce qu'il en trouve un qui soit premier.
On rappelle qu'un nombre entier est premier s'il n'a que 2 diviseurs distincts : 1 et lui-même.
Le programme devra, selon le nombre proposé par l'utilisateur :
● redemander un nombre si l'utilisateur en propose un négatif,
● donner une explication adaptée si le nombre proposé n'est pas premier,
● féliciter l'utilisateur et se terminer si le nombre est premier.
Voici un exemple d'exécution possible (sont notées en gras les données fournies par l'utilisateur) :
Pour trouver un nombre premier ...

Donner un entier strictement positif :
737
737 est divisible par 11 et par 67
-45
Donner un entier, qui doit etre strictement positif :
567
971
Bravo, vous avez trouve un nombre premier : 971
La difficulté de la programmation de cet exemple vient de l'imbrication entre trois causes de répétition
qui seront nécessairement présentes dans le programme et que l'on observe lors de son exécution :
● repétition lors de la saisie d'un nombre si l'utilisateur en propose un négatif,
● répétition de l'affichage des diviseurs si le nombre proposé n'est pas premier,
● répétition de la demande de nombres à l'utilisateur jusqu'à ce qu'il en propose un qui soit premier.
La méthode à employer pour écrire ce programme est de tenter de décomposer le traitement en

traitements moins complexes.
Up

Cours d'Informatique -- 7.1 Décomposer les traitements
Up Next
Suivant : 7.2 Fonctions et procédures
7.1 Décomposer les traitements

Face à un problème complexe, tel que la réalisation d'un programme dont on a posé les spécifications, on
cherche à séparer les difficultés et à trouver une méthode de résolution pour aboutir à l'écriture d'un
algorithme. C'est cette phase préliminaire que l'on appelle analyse.
Analyse descendante : L'analyse descendante est une méthode consistant à décomposer un problème
complexe en sous-problèmes indépendants les uns des autres, et dont la complexité est moindre que le
problème initial.
Chacun des sous-problèmes peut lui-même être décomposé à son tour, jusqu'à ce que chacun des
sous-problèmes ainsi définis soient réalisables - c'est à dire qu'on puisse écrire les algorithmes résolvant
ces problèmes.
Pour le problème donné en exemple, l'analyse consiste à séparer les traitements différents pour les
résoudre chacun à son tour. On y a observé trois niveaux de répétition que l'analyse doit réussir à séparer.
L'analyse descendante sous-entend que l'on envisage d'abord le problème au niveau global. Ceci permet
de choisir le niveau de répétition pertinent au niveau global, c'est-à-dire la répétition qui "englobe" les
autres.
● Analyse descendante de l'exemple
● Une première solution

Up Next

Cours d'Informatique -- 7.2 Fonctions et procédures
Prev Up Next
Précédent : 7.1 Décomposer les traitements
Suivant : Exercices
7.2 Fonctions et procédures

Fonctions et/ou procédures sont des notions permettant de structurer les programmes. Ces notions sont
présentes dans la plupart des langages de programmation. Fonctions ou procédures succèdent à la notion
de "sous-programme", notion introduite dans les premiers langages de programmation.
L'objectif est de permettre l'écriture d'un programme par juxtaposition de "morceaux de programmes"
résolvant chacun un sous-problème particulier.
Ainsi, fonctions et procédures permettent de réaliser un programme par analyse de ses sous-problèmes,
dans lequel la démarche d'analyse et de séparation des problèmes est visible y compris dans le
programme final.
Procédure : Une procédure est une séquence d'instructions identifiée par un nom (le nom de la
procédure). La notion de procédure permet de distinguer dans un programme :
● la définition d'une procédure : c'est l'écriture de son nom et de la séquence d'instructions qui la
composent,
● l'appel d'une procédure, qui s'effectue en écrivant uniquement son nom : c'est une instruction qui a
pour effet d'exécuter la séquence d'instructions associée au nom de la procédure.
Une procédure peut, de plus, avoir des paramètres qui peuvent être des paramètres d'entrée, de sortie ou à
la fois d'entrée et de sortie. Un paramètre est un nom donné à une information manipulée par la
procédure. Un paramètre d'entrée peut uniquement être utilisé dans la séquence d'instructions constituant
la procédure. Un paramètre de sortie doit être positionné par la séquence d'instructions. Un paramètre
d'entrée/sortie doit être positionné et peut être utilisé dans la séquence d'instructions.
Fonction : Une fonction est définie comme une procédure ayant au plus un paramètre de sortie.
L'appel d'une fonction est une expression dont la valeur est la valeur de son paramètre de sortie à l'issue
de l'exécution de la séquence d'instructions.
L'intérêt des fonctions et procédures est :
● de permettre d'écrire un programme en suivant l'analyse descendante,
● d'éviter d'écrire plusieurs fois une séquence d'instructions destinée à être exécutée plusieurs fois ; il
suffit alors d'en faire une procédure ou une fonction et de l'appeler autant de fois que nécessaire,
● de réutiliser facilement des traitements déjà écrits sous forme de fonctions ou de procédures,
● de partager le travail entre programmeurs lors de la résolution d'un problème informatique

complexe.
En tant que technique pour diviser un programme, ou pour partager le travail de programmation, il est

Cours d'Informatique -- 7.2 Fonctions et procédures
particulièrement important que ce qui est fait "à l'intérieur" d'une fonction ou procédure, soit
parfaitement délimité. En particulier, il faut que les informations manipulées par la fonction ou la
procédure lui soient indiquées comme paramètres : en entrée si ces informations sont seulement utilisées,
en sortie si elle sont produites par la fonction ou la procédure, en entrée/sortie si les informations fournies
peuvent être modifiées.
Les algorithmes des fonctions et procédures seront notés comme les algorithmes vus précédemment, en
ajoutant aux déclarations les paramètres utilisés ainsi que leur statut (entrée, entrée/sortie ou sortie).
Dans le cas particulier où l'on envisage de traduire un algorithme sous la forme d'une fonction, ou peut
omettre de donner un nom à l'unique paramètre de sortie, à condition de désigner dans l'algorithme la
valeur qui devra être donnée en résultat.
● Exemples simples de procédures et de fonctions
● Une solution structurée pour le problème des nombres premiers

● Traduction de la solution structurée en Pascal

Prev Up Next

Prev Up Next
Précédent : 7.2 Fonctions et procédures
Exercices
en annexe.
Exercice 7.1 : Simulation d'un programme Pascal avec des procédures
Soit le programme Pascal suivant :
program q;
procedure p (a: integer; var b : integer; c: integer);

var d : integer;
begin
d := b;
if a < b then begin b := a; a := d end;
d := c;
if b > c then begin c := b; b := d end
end;
var x,y,z : integer;

begin
x := 8; y := 6; z := 4;
p (x,y,2);
writeln(x);
p (z,x,y);
writeln(y);
p (y,z,x);
writeln(z)
end.
Quelles sont les valeurs (entières) affichées par l'exécution de ce programme ? Pour trouver ces valeurs,
exécuter le programme ligne à ligne en notant les valeurs des variables.
Exercice 7.2 : Différence de longueurs en pieds et pouces
Ecrire un algorithme qui, à partir de deux longueurs demandées à l'utilisateur et exprimées en pieds et
pouces, calcule et affiche en pieds et pouces la différence entre ces deux longueurs. Il est demandé de
réutiliser sous forme de fonctions ou de procédures les algorithmes démandés dans un exercice
précédent.

Exercice 7.3 : Jeu des allumettes

Le jeu des allumettes se joue à deux avec la règle suivante :
● le jeu commence avec un tas de 50 allumettes,
● chaque joueur prend à son tour un nombre d'allumettes compris entre 1 et 6 (dans la limite de ce
qui reste disponible) et fait ainsi diminuer le tas,
● le joueur qui se retrouve obligé de prendre la dernière allumette est perdant.
Ecrire l'algorithme qui permet de jouer à ce jeu. Les deux joueurs sont appelés joueur1 et joueur2. Pour
jouer il suffit de saisir un nombre dont on contrôlera la validité en utilisant une fonction ou une
procédure.
Avant chaque saisie on fait afficher le nombre d'allumettes du tas restant (on peut aussi afficher une
représentation du tas restant).
Lorsque le tas est vide, on affiche lequel des deux joueurs a gagné et au bout de combien de coups.
Prev Up Next

Prev Up Next
Suivant : 7.3 Analyser les traitements répétitifs
Exercice 7.1
Les entiers affichés successivement par ce programme sont :

822
Exercice 7.2
L'idée est de convertir les longueurs en mètres, de faire la différence et de convertir le résultat en pieds et pouces.
Les algorithmes de conversion, si on choisit de les écrire sous forme de procédures, peuvent s'écrire :
Algorithme PiedsPoucesEnMetres
{ Convertit une longueur exprimée en pieds et pouces en une longueur équivalente en mètres }
ENTREE LPieds entier donnée
ENTREE Lpouces entier donnée
SORTIE LMetres réel résultat
LOCALE TotalEnPouces entier calcul intermédiaire
début
TotalEnPouces <-- ((12 * LPieds) + Lpouces)

LMetres <-- (TotalEnPouces * 2.54) / 100
fin
Algorithme MetresEnPiedsPouces
{ Convertit une longueur exprimée en mètres en une longueur équivalente en pieds et pouces }
ENTREE LMetres réel donnée
SORTIE LPieds entier résultat
SORTIE Lpouces entier résultat
LOCALE TotalEnPouces entier calcul intermédiaire
début
TotalEnPouces <-- arrondi ((LMetres * 100) / 2.54)

LPieds <- TotalEnPouces div 12

Lpouces <- TotalEnPouces mod 12
fin
Le programme principal est alors le suivant :
Algorithme DifferencePiedsPouces
{ Programme principal }
LPieds1,Lpouces1,LPieds2,Lpouces2 entiers données
Lmetre1,Lmetre2 entiers intermédiaires
Lpieds, Lpouces entiers résultats
début
ecrire('Donnez la première longueur en pieds : ')

lire (LPieds1)
lire (Lpouces1)
ecrire('Donnez la seconde longueur en pieds : ')
lire (LPieds2)
lire (Lpouces2)
PiedsPoucesEnMetres(LPieds1,Lpouces1,Lmetre1)
PiedsPoucesEnMetres(LPieds2,Lpouces2,Lmetre2)
MetresEnPiedsPouces( valeurabsolue (Lmetre2 - Lmetre1),Lpieds,Lpouces)
ecrire ('La différence est : ', Lpieds, ' ft ', Lpouces, 'inch')
fin
On remarque que la procédure PiedsPoucesEnMetres est utilisée 2 fois. L'utilisation de cette procédure évite ainsi d'écrire les
calculs de conversion de pieds et pouces en mètres, pour chacune des deux longueurs données.
Exercice 7.3
La solution ci-dessous est donnée en JavaScript avec des fonctions, mais peut aussi être écrite en Pascal avec des fonctions
et/ou des procédures.
function Saisie (NbAllumettes, Numero)

{ var n
do
n = prompt('Joueur numero ' + Numero +
'Il reste ' + NbAllumettes + ' allumettes' +
'Combien en voulez vous ? (1 à ' + Math.min(6,NbAllumettes) + ')', 1)
while ( ! (n>=1 && n<=6 && n<=NbAllumettes))
return (n)
}
var Allumettes, joueur, prises

Allumettes = 50
joueur = 1
while (Allumettes !== 0)

{
prises = Saisie (Allumettes, joueur)
Allumettes = Allumettes - prises
if (joueur === 1)
joueur = 2
else joueur = 1
}
alert ('le joueur ' + joueur + ' a gagné !')

Prev Up Next

Cours d'Informatique -- 7.3 Analyser les traitements répétitifs
Prev Up Next
Suivant : Exercices
7.3 Analyser les traitements répétitifs

Maîtriser le développement d'un programme complexe peut se faire en décomposant le problème en
sous-problèmes distincts, ou bien en mettant en évidence une partie du traitement qui doit être répétée à
l'identique un certain nombre de fois, éventuellement sur des données différentes à chaque fois.
C'est à ce dernier cas que s'applique "l'analyse des traitements répétitifs", dont l'objectif est d'aider le
programmeur à écrire correctement un traitement répétitif, en se fiant à des schémas déjà éprouvés.
Les traitements répétitifs sont un outil puissant pour l'ordinateur (dont c'est d'ailleurs la principale
capacité) mais dont l'écriture doit être bien comprise. Le risque d'une mauvaise écriture peut-être :
● de ne pas repéter "assez longtemps" un traitement, ou de le répéter trop, ceci pouvant aller jusqu'à
une "exécution infinie" (on dit alors que le "programme boucle")
● de ne pas répéter le bon traitement, ou seulement une partie de ce traitement,
● de ne pas prévoir les cas particuliers, en particulier les cas où le traitement devrait être exécuté 1
seule fois ou 0 fois.
L'analyse des similarités et des différences entre les algorithmes répétitifs déjà écrits, permet de mettre en
évidence 3 schémas standards de traitements répétitifs, puis d'énoncer des règles permettant de choisir un
bon schéma.
● Introduction
● Des schémas standards

● Pour choisir un bon schéma

Prev Up Next

Prev Up Next
Précédent : 7.3 Analyser les traitements répétitifs
Exercices
en annexe.
Exercice 7.4 : Analyse d'algorithmes répétitifs
Etudier les algorithmes suivants, pour voir s'ils suivent un des schémas donnés, ou s'il aurait été possible
de les écrire en suivant un des schémas.
● algorithme de calcul de l'épargne
● algorithme de calcul de l'épargne (bis)

● algorithme de calcul de l'épargne (ter)
● algorithme de calcul de e
● algorithme d'affichage des marées
● algorithme de Syracuse
● algorithme de calcul de la moyenne d'un tableau
● algorithme de remplissage d'un tableau
● algorithme de remplissage d'un tableau (bis)
● algorithme d'affichage d'un tableau
● algorithme de recherche d'un nombre premier
● algorithme de lecture d'un entier strictement positif
● algorithme de test d'un nombre premier
● algorithme de calcul de la racine
Exercice 7.5 : Mise au point d'un programme JavaScript

Chercher l'erreur dans le programme JavaScript suivant :
A tester et modifier en le copiant dans la fenêtre JavaScript.
var x,p
alert ('Calcul du produit d\'une suite de nombres')

p = 1

x = prompt('Nombre ? (0 pour finir)', 1)

while (x != 0)
{
x = prompt('Nombre ? (0 pour finir)', 1)
p = p * x
}
alert ('le produit des nombres est : ' + p)
Exercice 7.6 : Affichage des carrés des nombres entiers
On s'intéresse à la suite des carrés des nombres entiers positifs : 1, 4, 9, 16, 25, 36, 49...
Analyser les problèmes suivants en les interprétant comme des traitements de séquence (N est une valeur
donnée par l'utilisateur).
● Afficher les N premiers carrés.
● Afficher à partir de 1 les carrés strictement inférieurs à N.
● Afficher à partir de 1 les carrés inférieurs ou égaux à N.
Ecrire les algorithmes correspondants, en essayant de suivre les schémas proposés.

Prev Up Next

Prev Up
Exercice 7.4
Les algorithmes suivants sont écrits selon le schéma des traitements de séquence de longueur inconnue
sans traitement du dernier :
● algorithme de calcul de l'épargne
● algorithme de calcul de la moyenne d'un tableau

● algorithme de remplissage d'un tableau
● algorithme de lecture d'un entier strictement positif
Seul l'algorithme de recherche d'un nombre premier est écrit selon le schéma "avec traitement du
dernier".
Les algorithmes suivants sont écrits selon le schéma des traitements de séquence de longueur connue :
● algorithme de calcul de l'épargne (ter)
● algorithme de calcul de e
● algorithme d'affichage des marées
● algorithme de remplissage d'un tableau (bis)
● algorithme d'affichage d'un tableau
● algorithme de test d'un nombre premier
Les suivants ne correspondent à aucun des schémas, mais auraient, pour certains, pu être écrits
différemment pour suivre un des schémas :
● Dans l'algorithme de calcul de l'épargne (bis), le traitement :
ecrire ('Montant...') est effectué avant le passage au suivant.
● Dans l'algorithme de Syracuse, contrairement au schéma utilisant tant que, le passage au
suivant (valeur suivante de la suite) est effectué avant son traitement (ecrire (n)). La conséquence
en est que le premier élément n'est pas écrit par cet algorithme.
● L'algorithme de calcul de la racine consiste à parcourir la suite des entiers jusqu'à obtenir la racine
d'un entier donné. Il n'y a pas de traitement de chacun des entiers ; cet algorithme ne rentre donc
pas vraiment dans le cadre des "traitements de séquence". Il aurait tout aussi bien pu être écrit :
Algorithme RacineBis
{ calcule la partie entiere de la racine carrée de a; essaye avec la variable b tous les entiers
depuis 1 }

début
b <-- 0
répéter
b <-- b + 1
jusqu'à (b*b <= a <(b+1)*(b+1))
le resultat est : b
fin
Exercice 7.5
L'exécution de ce programme donne toujours le résultat 0. Pourtant le programme "ressemble" au

traitement d'une séquence de nombres, avec comme traitement la multiplication dans p, et comme dernier
élément le nombre 0. Il ne faut pas que ce dernier nombre soit traité : ceci permet de choisir le bon
schéma. Encore faut-il le respecter (ce qui n'est pas le cas dans le programme donné)!
Exercice 7.6
Il s'agit dans les 3 cas de traitements d'une séquence d'entiers consécutifs. Le traitement consiste à
calculer et afficher le carré de l'entier courant. Passer à l'entier suivant consiste à ajouter 1 à l'entier
courant.
Les différences entre les 3 questions concernent le nombre d'entiers à traiter, et la manière de terminer le
traitement.
● Pour afficher les N premiers carrés, le nombre d'entiers à traiter (afficher leur carré) est N.
L'algorithme est alors :
Algorithme AfficherCarres1
{ Affiche N premier carrés }
N entier donné par l'utilisateur
i entier indice
début
lire (N)
pour i de 1 à N
ecrire (i * i)
fin pour
fin
● Pour afficher à partir de 1 les carrés strictement inférieurs à N, on choisit comme dernier élément

celui dont le carré est supérieur ou égal à N. Ce dernier élément n'est donc pas à traiter.
L'algorithme est alors :
{ Affiche carrés strictement inférieurs à N }
début
lire (N)
i <- 1
tant que i*i < N
ecrire (i * i)
i <- i + 1
fin tant que
fin
● On veut maintenent afficher à partir de 1 les carrés inférieurs ou égaux à N. Si on choisit comme
dernier élément celui dont le carré est supérieur à N, le dernier élément n'est pas à traiter.
{ Affiche carrés inférieurs ou égaux à N }
début
lire (N)
i <- 1
tant que i*i <= N
ecrire (i * i)
i <- i + 1
fin tant que
fin
Prev Up

Cours d'Informatique -- Analyse descendante de l'exemple
Up Next
Remonter : 7.1 Décomposer les traitements
Suivant : Une première solution
Analyse descendante de l'exemple

Le problème vu au niveau global :
● ne consiste pas qu'en la repétition de saisie d'un nombre jusqu'à ce que l'utilisateur en donne un positif,
● ne consiste pas qu'en la répétition de l'affichage des diviseurs d'un nombre si le nombre proposé n'est pas premier,
● mais est une répétition de demandes de nombres à l'utilisateur jusqu'à ce qu'il en propose un qui soit premier. Les deux
répétitions précédentes ne sont que des traitements "internes" à cette dernière répétition.
Algorithme NombrePremier
{ Demande un nombre positif, jusqu'à ce que l'utilisateur donne un nombre premier }
nombre entier le nombre demandé
premier booléen vrai ssi nombre est premier
début
ecrire ('Pour trouver un nombre premier ...')

répéter
Lire un entier strictement positif et l'appeler nombre
Tester si nombre est premier, afficher éventuellement ses diviseurs,
et enregistrer le resultat (vrai/faux) sous le nom: premier
jusqu'à premier
ecrire ('Bravo, vous avez trouve un nombre premier : ', nombre)
fin
A ce niveau de l'analyse, on a déjà choisi les variables nécessaires à l'expression du traitement global, qui est une répétition de
deux traitements particuliers qui pourront être précisés par la suite. Ces sous-problèmes sont :
● Lire un entier strictement positif et l'appeler nombre
● Tester si nombre est premier, afficher éventuellement ses diviseurs,

et enregistrer le resultat sous le nom: premier
Ces deux sous-problèmes peuvent être résolus indépendamment l'un de l'autre, dès que l'on a choisi quelles informations sont
utilisées et/ou produites par chacun des sous-problèmes.
Pour continuer l'analyse, on étudie le premier sous-problème. Il consiste en une répétition de saisies de nombres tant que
l'utilisateur entre des nombres négatifs ou nuls. Ce traitement doit se terminer avec une valeur strictement positive pour la variable
nombre.
ecrire('Donner un entier strictement positif : ')

lire(nombre)
tant que (nombre <= 0)
ecrire('Donner un entier, qui doit etre strictement positif : ')
lire(nombre)
fin tant que
Le second sous-problème est plus complexe, car pour savoir si un nombre est premier il faut tester s'il n'a que 2 diviseurs, 1 et
lui-même. Pour cela, on essaie de diviser nombre par tous les entiers compris entre 2 et la racine carrée de nombre. Si on en trouve
un, alors nombre n'est pas premier. L'algorithme est le suivant :

Cours d'Informatique -- Analyse descendante de l'exemple
si nombre = 1
alors premier <-- faux
sinon
premier <-- vrai
calculer la racine de nombre et enregistrer sous le nom : p
pour i de 2 à p
tester si nombre est divisible par i, enregistrer sous le nom : estdivpari
premier <-- premier et non estdivpari
fin pour
fin si
Les sous-problèmes à traiter par la suite sont :
● calculer la racine de nombre et enregistrer sous le nom : p
● tester si nombre est divisible par i, enregistrer sous le nom : estdivpari
Le premier peut être résolu par le fragment d'algorithme suivant, qui calcule la partie entière de la racine carrée d'un nombre entier
strictement positif :
p <-- 1
tant que non ( (p*p <= nombre) et (nombre <(p+1)*(p+1)) )
p <-- p + 1
fin tant que
Le dernier sous-problème consiste à tester si le reste de la division de nombre par i est nul, et si oui à afficher les 2 diviseurs de
nombre qui viennent d'être trouvés.
estdivpari <-- (nombre mod i) = 0

si estdivpari alors
ecrire (nombre, ' est divisible par ', i, ' et par ', nombre div i)
fin si
A l'issue de cette analyse, il faut remettre en place les morceaux d'algorithmes pour obtenir une solution globale au problème
complet. On obtient ainsi une imbrication correcte des différentes répétitions contenues dans cet algorithme.
Up Next

Cours d'Informatique -- Une première solution
Prev Up
Précédent : Analyse descendante de l'exemple
Remonter : 7.1 Décomposer les traitements
Une première solution

Pour obtenir cette solution, on a remis bout à bout tous les fragments d'algorithmes écrits précédemment.
Algorithme NombrePremierVersion1
{ Demande un nombre positif, jusqu'a ce que l'utilisateur donne un nombre premier }
premier booléen vrai ssi nombre est premier
estdivpari booléen vrai ssi nombre est divisible par i
i entier indice de boucle
p entier partie entiere de la racine carree de nombre
début

répéter
ecrire('Donner un entier strictement positif : ') { debut lire entier }
lire(n)
tant que (nombre <= 0)
lire(n)
fin tant que { fin lire entier }
si nombre = 1 { debut tester si premier }
alors premier <-- faux
sinon
premier <-- vrai
p <-- 1 { debut calcul racine }
tant que non ( (p*p <= nombre) et (nombre <(p+1)*(p+1)) )
p <-- p + 1
fin tant que { fin calcul racine }
pour i de 2 à p
estdivpari <-- (nombre mod i) = 0 { debut test divisible }
si estdivpari alors
ecrire (n, ' est divisible par ', i, ' et par ', nombre div i)
fin si { fin test divisible }
premier <-- premier et non estdivpari
fin pour
fin si { fin tester si premier }
jusqu'à premier
fin
Bien que la démarche pour obtenir cet algorithme ait été rigoureuse, il est difficile, a posteriori, de le comprendre, si l'on n'a

Cours d'Informatique -- Une première solution
pas suivi toutes les étapes de la conception, car on ne "voit" plus les différentes parties de l'algorithme tel qu'il a été conçu.
Prev Up

Cours d'Informatique -- Exemples simples de procédures et de fonctions
Up Next
Remonter : 7.2 Fonctions et procédures
Suivant : Une solution structurée pour le problème des nombres premiers
Exemples simples de procédures et de fonctions

Fonction ou procédure avec paramètres d'entrée
La fonction ou procédure suivante affiche sur une ligne la multiplication des deux entiers donnés en
paramètres :
Algorithme AfficheMul
{ Pose une multiplication et affiche son résultat }
ENTREE n,m entiers les parametres
début
ecrire (n , ' * ', m , ' = ' , n * m )

ecrire ('----------')
fin
Cette fonction ou procédure peut être appelée plusieurs fois à la suite, avec des données différentes, ce
que l'on notera de la façon suivante:
AfficheMul (4, 5)
AfficheMul (5, 6)
L'exécution de ce fragment d'algorithme a pour effet d'exécuter à chaque appel, la séquence d'instructions
associée, ce qui produit l'effet suivant :
4 * 5 = 20
----------
5 * 6 = 30
----------
Procédure avec paramètres d'entrée, de sortie et d'entrée/sortie
La procédure suivante a en entrée les scores (nombres entiers) de 2 joueurs, en entrée/sortie le meilleur
score obtenu jusqu'à présent, et en sortie le numéro du joueur gagnant parmi les 2 joueurs.
Algorithme MeilleurScore

{ met à jour le meilleur score après un match et calcule le gagnant de ce match }

ENTREE score1, score2 entiers scores des joueurs 1 et 2
ENTREE/SORTIE meilleur entier le meilleur score
SORTIE gagnant entier le joueur 1 ou 2
début
si score1 > score2

alors gagnant <- 1
si score1 > meilleur alors meilleur <- score1 fin si
sinon gagnant <- 2
si score2 > meilleur alors meilleur <- score2 fin si
fin si
fin
Cette procédure peut être appelée ainsi, si l'on suppose que HighestScore et BestPlayer sont des variables
entières. Les affichages produits par l'exécution sont notés en commentaires à droite :
HighestScore <- 0
MeilleurScore(12,14,HighestScore,BestPlayer)
ecrire(HighestScore,BestPlayer) { 14 2 }
Remarque : Peuvent être données en paramètres d'entrée des constantes (c'est le cas ici) ou des variables initialisées.
Ne peuvent être données en paramètres d'entrée/sortie que des variables initialisées (par exemple la variable
HighestScore).
Ne peuvent être données en paramètres de sortie que des variables. Ces variables n'ont pas besoin d'être initialisées (par
exemple la variable BestPlayer).
Le "morceau d'algorithme", utilisé ici en tant que procédure MeilleurScore peut aussi bien être écrit en
tant que fonction. On omet alors le nom du paramètre de sortie et on utilise la fonction par un appel de la
forme :
BestPlayer <- MeilleurScore(12,14,HighestScore)
Fonction

La fonction suivante calcule le maximum de deux scores (nombres entiers). Ces scores sont inchangés; le
seul résultat de la fonction est le maximum.
Algorithme Maximum
{ calcule le maximum de 2 entiers }
ENTREE score1, score2 entiers scores des joueurs 1 et 2
SORTIE entier le maximum
début
si score1 > score2

alors le résultat est : score1
sinon le résultat est : score2
fin si
fin
On peut utiliser cette fonction en l'appelant avec des valeurs particulières. La particularité de l'appel
d'une fonction (par rapport à une procédure) est d'être une expression ayant une valeur et pouvant donc
être intégrée dans un autre calcul.
Si on suppose que score est une variable entière, l'exécution du programme suivant produit les affichages
notés en commentaires à droite :
score <- Maximum (12, 14)

ecrire (score) { 14 }
ecrire (Maximum (20, 10)) { 20 }
score <- 10 + Maximum (15, 14)
score <- Maximum ( Maximum (20, 10), Maximum (12, 22))
Le dernier exemple montre que l'on peut très simplement calculer le maximum de 4 nombres en appelant
3 fois la fonction qui calcule le maximum de 2 nombres.
Up Next

Cours d'Informatique -- Une solution structurée pour le problème des nombres premiers
Prev Up Next
Précédent : Exemples simples de procédures et de fonctions
Une solution structurée pour le problème des nombres premiers

En respectant l'analyse descendante effectuée, on peut écrire une procédure ou fonction pour chacun des sous-problèmes.
On obtient alors la solution suivante. L'algorithme principal ne contient que la première phase de l'analyse. Les
sous-problèmes font appel à des procédures ou à des fonctions.
Algorithme NombrePremierVersion2
{ Demande un nombre positif, jusqu'a ce que l'utilisateur donne un nombre premier }
estunnombrepremier booléen vrai ssi nombre est premier
début

répéter
LireEntierStrictementPositif(nombre)
EstPremier(nombre,estunnombrepremier)
jusqu'à estunnombrepremier
fin
La fonction ou procédure de lecture d'un entier strictement positif peut s'écrire comme suit. Sa seule sortie est l'entier à
saisir par l'utilisateur.
Remarque : Attention, l'entier bien qu'il soit "entré" par l'utilisateur est bien un paramètre de sortie. En effet il n'a pas de valeur avant
l'exécution, et il a une valeur après : c'est donc bien un résultat de l'exécution de la fonction ou procédure.
Algorithme LireEntierStrictementPositif
{ Saisie d'un nombre strictement positif }
SORTIE n entier le nombre saisi
début
ecrire('Donner un entier strictement positif : ')

lire(n)
tant que (n <= 0)
lire(n)
fin tant que

fin
La fonction ou procédure suivante calcule un résultat booléen (vrai ou faux), indiquant si le nombre donné en entrée est
premier.
Algorithme EstPremier
{ teste si le nombre donné est premier }
ENTREE n entier l'entier donné
SORTIE premier booléen vrai ssi n est premier
LOCALE i entier indice de boucle
LOCALE p entier partie entiere de la racine carree de n
LOCALE nestpasdivisible booléen vrai ssi n n'est pas divisible
LOCALE estdivisiblepari booléen vrai ssi n est divisible par i
début
si n = 1
alors premier <-- false { 1 n'est pas un nombre premier }
sinon
nestpasdivisible <-- true { n est premier si et seulement si n }
{ n'est divisible par aucun i }
pour i de 2 à Racine(n) { compris entre 2 et la racine carree de n }
estdivisiblepari <- EstDivisiblePar(n,i)
nestpasdivisible <-- nestpasdivisible and not estdivisiblepari
fin pour
premier <-- nestpasdivisible
fin si
fin
Le calcul de la partie entière de la racine carrée est écrit ici comme une fonction, ce qui permet dans l'algorithme
précédent de désigner la racine de l'entier n, par l'appel Racine(n).
Algorithme Racine
{ calcule la partie entiere de la racine carrée de a; essaye avec la variable b tous les entiers depuis 1 }
ENTREE a entier donnée
SORTIE entier résultat
LOCALE b entier essais successifs
début
b <-- 1
tant que non ( (b*b <= a <(b+1)*(b+1)) )
b <-- b + 1

fin tant que

le resultat est : b
fin
Le dernier sous-problème à résoudre peut aussi être écrit sous forme d'une fonction, qui teste la divisibilité d'un entier par
un autre.
Algorithme EstDivisiblePar
{ Test et affiche si x est divisible par y }
ENTREE x entier le dividende
ENTREE y entier le diviseur
SORTIE booléen
début
si (x mod y) = 0
alors ecrire (x, ' est divisible par ', y, ' et par ', x div y)
fin si
le résultat est : (x mod y) = 0
fin
Un tel algorithme structuré peut être traduit directement dans un langage de programmation particulier en utilisant les
notions de fonction et/ou de procédure disponibles dans le langage utilisé.
Prev Up Next

Prev Up Next
Précédent : Une solution structurée pour le problème des nombres premiers
Suivant : Traduction de la solution structurée en Pascal

Le langage Pascal propose les fonctions et les procédures. Le langage JavaScript ne dispose que de la
notion de fonction.
Pour ces deux langages les fonctions et procédures doivent être définies avant d'être utilisées. Le plus
simple est de définir une seule liste de fonctions et procédures dans un ordre convenable; en Pascal on
peut de plus définir une procédure à l'intérieur de la définition d'une autre procédure, mais dans ce cas la
procédure interne ne peut être utilisée que depuis la procédure qui la contient.
Les procédures en Pascal
La déclaration d'une procédure en Pascal suit la syntaxe suivante :

procedure nom ( parametres );
declarations
begin
sequence
end;
Ses paramètres s'écrivent selon la syntaxe :

[ var ] nom { , nom } : type ;
...
[ var ] nom { , nom } : type
Le mot var (optionnel) n'est utilisé que pour les paramètres de sortie et d'entrée/sortie.
L'appel d'une procédure en Pascal est une instruction de la forme :
nom ( expression { , expression } )
Les fonctions en Pascal et en JavaScript
La déclaration d'une fonction en Pascal suit la syntaxe suivante :

function nom ( parametres ): type ;
declarations
begin
sequence
end;

La séquence d'instructions doit contenir une, ou plusieurs, instructions permettant de définir la valeur du
résultat de la fonction. Cette instruction, où nom est le nom de la fonction, est notée:
nom := expression
L'appel d'une fonction en Pascal est une expression de la forme :

nom ( expression { , expression } )
La déclaration d'une fonction en JavaScript suit la syntaxe suivante :

function Nom ( Parametres )
{
{ Declaration de variables }
Sequence
}
La séquence d'instructions doit contenir une, ou plusieurs, instructions permettant de définir la valeur du
résultat de la fonction. Cette instruction, en JavaScript, est notée:
return ( Expression )
L'appel d'une fonction en JavaScript est une expression de la forme :

Nom ( Expression { , Expression } )
L'appel peut aussi être utilisé en tant qu'instruction si la valeur retournée par la fonction n'a pas
d'importance. Cela arrive par exemple quand la fonction est utilisée pour provoquer des affichages. Cela
revient à en faire une procédure sans sortie.
Prev Up Next

Cours d'Informatique -- Traduction de la solution structurée en Pascal
Prev Up
Précédent : De l'algorithme au programme Pascal ou JavaScript
Traduction de la solution structurée en Pascal

Pour traduire les algorithmes en Pascal, il faut mettre dans le bon ordre les fonctions et procédures, avant le programme principal.
program NombrePremier; {
Demande un nombre positif, jusqu'a ce que }
{ l'utilisateur donne un nombre premier }
procedure LireEntierStrictementPositif(var n: integer);
begin { Saisie d'un nombre strictement positif }
writeln('Donner un entier strictement positif : ');
readln(n);
while (n <= 0) do
begin
writeln('Donner un entier, qui doit etre strictement positif : ');
readln(n);
end
end;
function EstDivisiblePar(x,y:integer): boolean;
begin { Test et affiche si x est divisible par y }
if (x mod y)=0 then writeln (x, ' est divisible par ', y, ' et par ', x div y);
EstDivisiblePar := (x mod y) = 0;
end;
function Racine(a:integer): integer;
var b: integer;
begin { calcule dans b, la partie entiere de la racine }
b := 1; { carree de a; essaye tous les entiers depuis 1 }
while not ( (b*b <= a) and (a <(b+1)*(b+1)) )
do b := b + 1;
Racine := b
end;
procedure EstPremier(n:integer; var premier: boolean);
var i : integer; { teste si le nombre n est premier }
nestpasdivisible: boolean; { le resultat (vrai ou faux) est dans:premier }
estdivisiblepari: boolean;
begin
if n = 1
then premier := false { 1 n'est pas un nombre premier }
else
begin
nestpasdivisible := true; { n est premier si et seulement si n n'est }
{ divisible par aucun nombre i compris }
for i:= 2 to Racine(n) do { entre 2 et la racine carree de n }
begin estdivisiblepari := EstDivisiblePar(n,i);
nestpasdivisible := nestpasdivisible and not estdivisiblepari
end;
premier := nestpasdivisible
end
end;
var nombre : integer;
estunnombrepremier : boolean;
begin { Debut du programme principal }
writeln ('Pour trouver un nombre premier ...');
repeat

Cours d'Informatique -- Traduction de la solution structurée en Pascal
LireEntierStrictementPositif(nombre);
EstPremier(nombre,estunnombrepremier)
until estunnombrepremier;
writeln ('Bravo, vous avez trouve un nombre premier : ', nombre);
end.
Prev Up

Cours d'Informatique -- Introduction
Up Next
Remonter : 7.3 Analyser les traitements répétitifs
Suivant : Des schémas standards
Introduction
L'algorithme de conversion de francs en euros, et l'algorithme de calcul de la moyenne d'une série de
mesures ont en commun d'être des traitements répétitifs, consistant à répéter un même traitement sur une
suite d'informations différentes. Dans ces deux algorithmes, on ne sait pas, au début de la répétition,
combien de fois le traitement devra être répété. S'enchaînent à chaque fois, l'obtention d'une nouvelle
information et son traitement.
● Pour la conversion de francs en euros, l'obtention d'une nouvelle information (un montant en
francs) consiste à la demander à l'utilisateur ; son traitement est le calcul et l'affichage du montant
en euros ; la fin de la répétition est provoquée par une information particulière (un montant nul)
que le programme n'a pas à traiter.
● Pour le calcul de la moyenne d'une série de mesures, l'obtention d'une nouvelle information (une
mesure) consiste à la demander à l'utilisateur ; son traitement consiste à compter cette mesure et à
l'additionner à la somme ; la fin de la répétition est provoquée par une information particulière
(une mesure négative) que le programme n'a pas à traiter.
Dans ces deux algorithmes le schéma d'exécution est le même. Il consiste à traiter une séquence
d'informations dont on ne connait pas le nombre au départ.
Traitement de séquence : Identifier un problème, comme étant un traitement de séquence, consiste
à:
● mettre en évidence la séquence d'informations destinées à subir le même traitement,
● identifier la premiere information,
● séparer le traitement d'une information et l'obtention de l'information suivante,
● savoir comment reconnaître la dernière information.

Up Next

Cours d'Informatique -- Des schémas standards
Prev Up Next
Précédent : Introduction
Suivant : Pour choisir un bon schéma
Des schémas standards

Les exemples précédents respectent le schéma suivant :
Algorithme SchemaSansDernier
{ Traitement d'une séquence dont on ne connaît pas la longueur, et dont on ne traite pas la dernière
information }
début
obtenir la première information

tant que ce n'est pas la dernière
traiter l'information en cours
obtenir l'information suivante
fin tant que
fin
Parmi les problèmes pouvant être modélisés comme des traitements de séquences dont on ne connaît pas
la longueur, l'autre cas courant concerne les séquences dont toutes les informations doivent être traitées
de la même façon y compris la dernière. Ces problèmes peuvent alors être programmés selon le schéma
suivant :
Algorithme SchemaAvecDernier
{ Traitement d'une séquence dont on ne connaît pas la longueur, et dont on traite la dernière information
}
début
répéter
obtenir l'information suivante
traiter l'information en cours
jusqu'à la dernière
fin
Dans le cas particulier du traitement d'une séquence d'informations dont on connaît la longueur N avant
le début de l'exécution, on peut utiliser le schéma suivant :
Algorithme SchemaNFois
{ Traitement d'une séquence dont on connaît la longueur }

Cours d'Informatique -- Des schémas standards
début
pour i de 1 à N
obtenir ieme information
traiter ieme information
fin pour
fin
Prev Up Next

Cours d'Informatique -- Pour choisir un bon schéma
Prev Up
Précédent : Des schémas standards
Pour choisir un bon schéma

La première phase consiste à identifier clairement le problème en tant que traitement d'une séquence
d'informations. Si cela est possible, alors il suffit de savoir si la longueur de la séquence est connue avant
l'exécution, et sinon de décider s'il faut ou non traiter le dernier élément.
On peut alors utiliser un des schémas proposés. Ces schémas sont ainsi une aide à la programmation car
en fournissant un cadre, ils évitent des erreurs et oublis classiques dans les traitements répétitifs :
● l'oubli de l'acquisition de la première information avant une construction tant que provoque
une erreur lors du premier test ;
● une répétition qui "boucle" est souvent la conséquence de l'oubli des instructions permettant
d'obtenir l'information suivante ou d'une mauvaise écriture de la condition "c'est la dernière" ;
Ces schémas ne sont cependant qu'une assistance au programmeur : ils peuvent d'une part être
contournés ; d'autre part ils ne dispensent pas le programmeur du nécessaire regard critique sur ce que
fait le programme qu'il est en train de concevoir.
Prev Up

Cours d'Informatique -- 9 En conclusion
Prev Up Next
Précédent : 8 Pour aller plus loin
Remonter : Top
Suivant : References
9 En conclusion
Conclure ce cours ...ou ne pas conclure ce cours ?
Le lecteur aura le choix de conserver pour lui la matière développée dans ce cours pour :
● ne plus risquer de "mourir idiot" en ne connaissant pas le mulot. L'utilisateur ainsi initié peut
revenir à ses premières amours (que ce soit l'anthropologie ou l'étude des dérivés du benzène). Il
ne risque plus de se faire "rouler" par un informaticien peu scrupuleux, voulant lui vendre une
vessie pour une lanterne, et ne lui donnant en fait qu'une copie de la dite vessie sur une disquette
infectée par un méchant virus.
● oser continuer sur la voie d'une professionnalisation en informatique, après ce premier tour
d'horizon, de la discipline, de ses concepts et de ses méthodes de travail. Il lui faudra alors
continuer à acquérir toute la rigueur et l'imagination nécessaire à la conception des objets
informatiques utiles pour lui (parfois) mais surtout pour les autres (ceux qui auront fait le premier
choix).
Prev Up Next

Cours d'Informatique -- 8.1 Domaines d'application de l'informatique
Up Next
Suivant : 8.2 La tour de Babel
8.1 Domaines d'application de l'informatique

Il peut paraître vain de tenter d'énumérer l'ensemble des domaines d'application de l'informatique tant
ceux-ci envahissent la plupart des domaines de l'activité humaine.
On peut cependant tenter une classification selon le secteur d'activité, le type d'informations et de
traitement informatique, et selon le type de communication entre l'ordinateur et son environnement.
Parmi les secteurs d'activité principaux, on peut citer :
● le domaine banque/finance/comptabilité : les informations manipulées sont des nombres (de
l'argent) et des informations nominatives. Les systèmes de traitement de l'information peuvent être
plus ou moins centralisés ou répartis géographiquement. De nombreux ordinateurs sont souvent
reliés en réseau. Les problèmes de sécurité sont, dans ce domaine, des problèmes d'argent!
● le domaine industriel : les ordinateurs peuvent être utilisés pour contrôler un (ou des) robot(s), une
chaîne de fabrication, une usine entière. Selon les cas, un seul ordinateur contrôle, un ou plusieurs
équipements, ou plusieurs ordinateurs communiquent, par un réseau informatique, pour contrôler
ensemble, l'ensemble des équipements industriels. La particularité de ce domaine est de nécessiter
des ordinateurs fonctionnant en permanence, c'est-à-dire tant que le procédé industriel à
commander est en activité. C'est aussi le cas des "systèmes embarqués" - les ordinateurs
embarqués sur un engin quelconque (une voiture, une fusée, un avion, un satellite, une carte de
crédit, une machine à laver, un paquebot ...). Parmi les particularités des systèmes embarqués, les
plus caractéristiques sont d'être des "systèmes fermés" (fonctionnement possible en l'absence
d'intervention de l'utilisateur), et de poser des problèmes de sécurité critique pour les équipements
et parfois pour des vies humaines. Par exemple :
❍ il n'est pas possible d'envoyer quelqu'un "rebooter" (réinitialiser) l'ordinateur pilotant un
satellite ;
❍ l'ordinateur commandant le système anti-blocage des roues (ABS), ne doit pas s'arrêter
pendant le fonctionnement de la voiture ;
❍ l'ordinateur de bord d'un lanceur de satellites ne doit provoquer l'auto-destruction de la fusée
que si cela est strictement nécessaire.
● le domaine scientifique et l'ingénierie : l'informatique a d'abord permis de réaliser plus vite et plus
précisément les calculs nécessaires à la conception de systèmes en tous genres. La puissance de
calcul des ordinateurs permet actuellement la "simulation" de ces systèmes. Le principe de la
simulation est de diviser (virtuellement) le système à simuler en petits éléments et de faire calculer
par l'ordinateur les interactions de ces éléments entre eux au cours du temps (selon les lois de la
physique), pour en déduire le comportement global du système. Il est ainsi possible de simuler, par
exemple :

Cours d'Informatique -- 8.1 Domaines d'application de l'informatique
❍ l'évolution du temps pour extrapoler des prévisions météorologiques,

❍ une explosion thermo-nucléaire (sans émettre de radiations),
❍ le passage de véhicules sur un ouvrage d'art en béton.
❍ ...et bien d'autres phénomènes naturels ou artificiels.
● les domaines de la téléphonie, des communications et des médias : la passage de la technologie

analogique à la technologie numérique transforme en profondeur ces domaines. En effet le codage
numérique permet la transmission du texte, de la voix, du son, des images fixes ou vidéo et leur
traitement par ordinateur. De nombreux dispositifs, jadis séparés, peuvent ainsi coopérer ou se
mélanger pour aboutir à de nouveaux dispositifs. L'évolution est rapide et constante dans ces
domaines, soutenue par le succès des technologies liées au réseau internet.
Cette tentative de classification ne veut pas ériger de frontières étanches entre les différents domaines. En
effet il est possible par exemple de gérer avec un seul ordinateur ou un groupe d'ordinateurs, une
application de contrôle d'un procédé industriel, connectée d'une part avec un système de téléphonie pour
alerte automatique en cas d'urgence et d'autre part avec une application de gestion en temps réel des
stocks.
La difficulté de l'analyse par secteurs d'activité, vient aussi du fait qu'une même société peut fabriquer
des ordinateurs, en utiliser pour contrôler sa chaîne de fabrication et en utiliser aussi pour tenir sa
comptabilité.
Le type des communications entre l'ordinateur et son environnement permettent aussi de classer les
ordinateurs et leurs applications. Un ordinateur peut en effet "changer de forme" - avoir un aspect
extérieur et des organes de communications différents - selon l'application à laquelle il est destiné. Un
même processeur (élément central de l'ordinateur contenant les capacités de calcul et de mémoire) peut
ainsi être utilisé :
● dans un ordinateur personnel pour une application de bureautique,
● dans une console de jeu,
● embarqué dans une voiture pour contrôler l'injection.
Selon le domaine d'application, la communication entre l'ordinateur et son utilisateur (ou d'autres
ordinateurs) peut donc être différente.
La programmation des ordinateurs doit donc aussi s'adapter au domaine d'application visé, car les
dispositifs de communication changent, et les comportements attendus de l'ordinateur sont différents d'un
domaine à l'autre.
Up Next

Cours d'Informatique -- 8.3 Théories fondamentales
Prev Up
Précédent : 8.2 La tour de Babel
8.3 Théories fondamentales

L'informatique hérite certaines de ses théories fondamendales des mathématiques. Ces théories ont eu
depuis d'importants développements spécifiquement pour l'informatique [Bel98][Xuo92].
Parmi les incoutournables théories donnant ses fondements à l'informatique, il faut citer :
● la théorie des fonctions calculables (travaux de Church), et les machines abstraites (dont la célèbre
machine de Turing) permettent de délimiter théoriquement le domaine de ce qu'un ordinateur peut
traiter, et fournit un modèle d'ordinateur abstrait calculant ces fonctions ;
● le modèle de Von Neumann (1945) propose une architecture générale des ordinateurs encore
utilisée actuellement ;
● la théorie des automates donne des modèles concrets de machine, d'usage général ou utilisées pour
reconnaître les phrases des langages informatiques. La théorie des automates fonde ainsi à la fois
la construction des ordinateurs et la conception des compilateurs des langages ;
● la théorie des langages s'est développée, adossée à la précédente, pour définir ce qu'est un langage
(au sens informatique), classifier les types de langages et définir comment analyser les phrases
d'un langage donné ;
● la logique - ou plutôt les logiques - permettent de donner un sens à ce qui dans un programme
contrôle son exécution. La logique est alors l'univers dans lequel on peut raisonner sur les
programmes : dire que 2 programmes sont "équivalents", qu'un programme se termine quelles que
soient les données fournies ...
Sur ces bases ont pu se développer les théories et techniques suivantes de l'informatique :
● la conception des architectures d'ordinateur des points de vue matériel et logiciel [AFL+00],
● les systèmes d'exploitation et logiciels de base nécessaires au fonctionnement des ordinateurs et

réseaux informatiques [Kra85][Tan99],
● les langages de programmation avec leurs modes d'expression variés et les techniques de
compilation associées,
● "l'intelligence artificielle", c'est-à-dire tout ce qui concerne la modélisation des connaissances et du
raisonnement en vue de l'automatiser,
● de nombreuses techniques spécifiques au traitement de la parole, des images, des bases de
données, des signaux ...et de tout autre type d'information selon le domaine d'application visé,
● le "génie logiciel", c'est-à-dire la "méthode" employée pour concevoir tout ce qui précède, dont en
particulier les techniques de spécification, de validation, de preuve, de tests.
● ...
Ce bref panorama ne peut bien sûr être que partiel et ...provisoire.

Cours d'Informatique -- 8.3 Théories fondamentales

Prev Up

JavaScript dans une page HTML
JavaScript dans une page HTML
http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/demojava.html [16-11-2001 19:58:32]

Cours d'Informatique -- Index
Prev Up Next
Précédent : References
Remonter : Top
Suivant : Glossaire
Index
ABCDEFGHIJKLMNOPQRSTUVWXYZ
A
Adresse IP
Affectation
Algorithme
Analyse descendante
ASCII
B
Bit
C
Cliquer
Codage en binaire
Complément à 2
Connexion
Courrier électronique
D
Déclarations
E
Expression
F
Fenêtre
Fichier
Fonction
Format
H
HTML
HTTP
Hypertexte

I
Icône
Informatique
Internet
L
langage
Logiciel
Logiciel de navigation
M
MHz
MIPS
Mémoire
O
Octet
Ordinateur
Ordinateur personnel
P
P.A.O.
PostScript
Pour
Procédure
Programme
Protocole de communication
R
RAM
ROM
Répéter ... jusqu'à
Réseau local
S
Selon
Serveur
Si...alors...sinon
simulation
Système d'exploitation
Séquence
T
Tableau

Tableur
Tableur
Tant que
Technologie analogique
Technologie numérique
Toile d'araignée mondiale
Traitement de séquence
Traitement de texte
Tri
Type
U
Unité centrale
V
Variable
Vecteur
Virgule flottante

Prev Up Next

Cours d'Informatique -- A Annexes
Prev Up Next
Précédent : Glossaire
Remonter : Top
Suivant : 10 Informations sur quelques logiciels d'usage courant
A Annexes
Prev Up Next

Cours d'Informatique -- 10 Informations sur quelques logiciels d'usage courant
Prev Up Next
Précédent : A Annexes
Remonter : Top
Suivant : 11 Référence rapide du langage Pascal
10 Informations sur quelques logiciels d'usage courant

Parmi les logiciels d'usage le plus répandu, les outils de bureautique et de communication figurent en bonne position : le traitement de texte, le tableur, le courrier
électronique.
Ces outils peuvent être rassemblés dans une "suite bureautique" ou "logiciel intégré", qui rassemble alors les fonctionnalités précédentes dans un seul logiciel, auxquelles
s'ajoutent souvent des outils de création graphique (dessin, présentation pour vidéo-projection) et de création de pages html pour internet.
La figure 10 donne une illustration de la fenêtre de démarrage d'un logiciel intégré offrant toutes ces possibilités. Chaque outil est accessible par son icône. De nombreuses
fonctionnalités sont disponibles pour associer différents types d'informations (textes, images, tableaux ...) dans un même document. Les fonctionnalités du logiciel sont
accessibles par les menus déroulants ou par les bandeaux d'icônes situés dans la partie haute de la fenêtre. On reconnait en particulier la fonction de sauvegarde (symbolisée
par une disquette), et les fonctions couper (symbolisée par des ciseaux)/copier/coller.

Fenêtre de démarrage d'un logiciel intégré (StarOffice ©Sun Microsystems)

La figure 10 donne une illustration de la fenêtre d'un traitement de texte, ouvert sur un fichier contenant le début de ce cours.

On peut remarquer la présence d'un deuxième bandeau d'icônes, spécifique au traitement de textes, qui permet d'accéder simplement :
● au choix de la police de caractères (ici times),
● à la taille des caractères (ici 14 points),
● à leur style (gras, italique, sous-ligné),
● à la justification (texte centré, cadré à droite, à gauche ou les deux),
● à la gestion des paragraphes d'énumération (comme celui-ci) avec des puces ou des numéros.
De très nombreuses possibilités sont disponibles dans les traitements de textes modernes. Elles sont généralement documentées dans le système d'aide du logiciel (ici c'est
le point d'interrogation en haut à droite). Il ne faut cependant pas abuser de toutes les possibilités offertes au risque de rendre un texte illisible. Des règles de typographie
existent pour guider le rédacteur dans sa tâche.

Exemple de traitement de texte

La figure 10 donne une illustration de la fenêtre d'un outil de dessin. Les bandeaux sont, ici encore, spécifiques aux actions disponibles pour dessiner. Les icônes permettent
de visualiser ces fonctions et de les retrouver facilement (après les avoir essayées pour en comprendre l'action).
Le principe des outils de dessins de ce genre est de dessiner des objets simples (rectangles, ovales, lignes ...) qui peuvent avoir un contour et une surface, puis de les
composer entre eux et de les modifier (réduction/agrandissement/rotation/symétrie) si nécessaire.

Exemple d'outil de dessin

Les autres outils disponibles dans un logiciel intégré s'utilisent selon les mêmes principes :
● Les menus, et bandeaux varient selon le type de document en cours de création ou modification.
● Les choix possibles dans les menus ou parmi les icônes (sont impossibles les choix et icônes notés en grisé) dépendent des actions précédentes de l'utilisateur. Par
exemple, il n'est possible de couper un morceau de texte ou d'image qu'après l'avoir désigné (sélectionné) avec la souris.
● La compatibilité des outils permet d'intégrer, quand cela a un sens, un type d'information, dans un document d'un autre type (une image dans un texte par exemple).

Prev Up Next

Cours d'Informatique -- Syntaxe
Up Next
Remonter : 11 Référence rapide du langage Pascal
Suivant : Déclarations et types
Syntaxe
La syntaxe présentée ici ne décrit qu'une partie du langage Pascal tel qu'il a été normalisé (Pascal ANSI). Ceci suffit
cependant pour les notions abordées dans le cadre de ce cours.
● Comment lire une description de syntaxe
● Syntaxe d'un programme et des instructions
● Syntaxe des expressions
● Syntaxe des déclarations

Up Next

Cours d'Informatique -- Déclarations et types
Prev Up Next
Précédent : Syntaxe
Suivant : Compilation et exécution
Déclarations et types
Le respect de la syntaxe ne veut pas dire qu'un programme soit "correct" et qu'il peut être exécuté.
Auparavant il faut vérifier que le programme est cohérent du point de vue des types et des déclarations.
● Tout identificateur (de variable, de constante, de type, de procédure) utilisé dans le programme
doit avoir été "déclaré" au préalable.
● L'utilisation des variables et des constantes dans une expression doit être compatible avec leurs
types. Par exemple, si x est une variable entière, x + 3 est correct, alors que x + 'bonjour'
n'est pas correct (bien que la syntaxe accepte cela).
En Pascal, ces vérifications sont effectuées automatiquement avant l'exécution (au moment de la
compilation). Il est important de comprendre la nature des vérifications effectuées, pour comprendre les
messages d'erreurs adressés au programmeur.
Prev Up Next

Cours d'Informatique -- Compilation et exécution
Prev Up
Précédent : Déclarations et types
Compilation et exécution
Pour exécuter un programme Pascal il faut au préalable l'avoir compilé - c'est-à-dire traduit dans le
langage (binaire) des instructions à exécuter par l'ordinateur. La compilation peut se faire dans l'un des
modes suivants :
● explicitement : par une commande, le programmeur demande la compilation de son programme.
Cette commande prend en entrée le fichier (texte) contenant le texte du programme, et produit en
sortie un fichier (binaire) comportant le code exécutable.
● implicitement : la compilation peut, dans certains systèmes, être effectuée au moment où le
programmeur demande "l'exécution de son programme". L'étape de compilation est la même que
précédemment : elle est simplement cachée au programmeur. C'est le cas des environnements de
programmation "grand-public", ou l'éditeur de texte et le compilateur sont réunis dans un même
logiciel.
Prev Up

Cours d'Informatique -- Comment lire une description de syntaxe
Up Next
Remonter : Syntaxe
Suivant : Syntaxe d'un programme et des instructions
Comment lire une description de syntaxe

La syntaxe d'un langage est décrite par un ensemble de règles de grammaire de la forme suivante :
phrase ::= sujet verbe le sujet fait
complement l'action
. indiquée
par le verbe
appliquée
au
complément
sujet ::= Je un sujet
particulier :
moi
| Le chat un autre
sujet
possible
verbe ::= mange un verbe
| regarde un autre
verbe
::= une un
complement souris complément
| une un autre
fleur complément
possible
Ces règles se lisent :

une phrase doit comporter un sujet, un verbe et un complément et se terminer par un point.
Le sujet peut être : je ou bien : le chat...
Les commentaires en partie droite indiquent le sens qu'il faut donner à une phrase ainsi construite.
Les règles définissent l'ensemble des phrases qu'il est possible d'écrire dans le langage, ici une (toute)
petite partie de la langue française :
Exemples :
Je regarde une fleur

Le chat mange une souris
Le chat mange une fleur

Cours d'Informatique -- Comment lire une description de syntaxe
La syntaxe d'un langage de programmation est décrite de façon analogue par des règles de grammaire.
Pour écrire un programme dont la forme (syntaxe) soit correcte, il suffit de :
● commencer par la première règle programme ,
● écrire les mots clés prévus,
● substituer les parties restant à définir, en cherchant les règles correspondantes,
● recommencer l'opération précédente jusqu'à ce qu'il ne reste plus rien à définir.
Les notations suivantes sont utilisées pour écrire les règles de grammaire (à ne pas confondre avec les
mots clés devant être écrits dans un programme) :
● les choix sont séparés par des |,
● les crochets [ ] notent les parties optionnelles,
● les accolades { } notent les parties pouvant être répétées un nombre quelconque (éventuellement
nul) de fois,
● le signe ...indique que la ligne précédente peut être répétée un nombre quelconque (éventuellement
nul) de fois.
Up Next

Cours d'Informatique -- Syntaxe d'un programme et des instructions
Prev Up Next
Précédent : Comment lire une description de syntaxe
Remonter : Syntaxe
Suivant : Syntaxe des expressions
Syntaxe d'un programme et des instructions

Les commentaires en partie droite font référence aux notations utilisées pour écrire les algorithmes, et
permettent ainsi de préciser le sens à donner aux constructions du langage Pascal.
::= program programme
programme nom ; principal
declarations
begin
sequence
end.
::= instruction séquence
sequence ; d'instructions
...
instruction
::= variable := affectation

instruction expression
| readln( lecture
variable { ,
variable } )
| writeln( écriture
expression {
, expression
})
| nom ( appel d'une
expression { procédure
, expression
})
| if si ...alors
expression
then
instruction

| if si ...alors
expression ...sinon
then
instruction
else
instruction
| while tant que ...
expression
do
instruction
| repeat répéter
sequence ...jusqu'à
until
expression
| for pour ...(par
variable := pas de +1)
expression
to
expression
do
instruction
| for pour ...(par
variable := pas de -1)
expression
downto
expression
do
instruction
| case selon ...
expression
of
liste de
constantes :
instruction
;
...
liste de
constantes :
instruction
;
[
otherwise

instruction ]
end
| begin bloc
sequence d'instructions
end
liste de ::= constante entiers ou
constantes {, caractères
constante pour
} l'instruction:
selon
::= suite de nom de
nom lettres et de type, de
chiffres, constante,
commençant du
par une programme
lettre

Prev Up Next

Cours d'Informatique -- Syntaxe des déclarations
Prev Up
Précédent : Syntaxe des expressions
Remonter : Syntaxe
Syntaxe des déclarations

::= [ chaque
declarations declarations déclaration
des est
constantes ] facultative
[
declarations
des types ]
[
declarations
des
variables ]
[ fonctions
et
procedures
]
::= const permet de
declarations nom = donner un nom
des constante à une valeur
constantes ; utilisée
... couramment,
nom = par exemple:
constante const pi =
3.14159265359
;

::= type permet

declarations nom = de
des types array[ donner
constante un nom
.. aux
constante types de
]of type vecteurs
utilisés
;
...
nom =
array[
constante
..
constante
]of type
;
::= var on peut
declarations nom déclarer
des { , une liste
variables nom de
} : variables
type de même
; type
...
nom
{,
nom
}:
type
;
::= integer entier
type
| boolean booléen
| real réel
| char caractère
| string chaîne de
caractères
| nom type défini
précédemment

fonctions ::= { on peut

et fonction déclarer
procedures ou plusieurs
procedure fonctions
} et
procédures
fonction ::= procedure une
ou nom ( procédure
procedure parametres
);
declarations
begin
sequence
end;
| function une
nom ( fonction
parametres
): type ;
declarations
begin
sequence
end;
::= [ le mot var
parametres var (optionnel)
] est utilisé
nom pour les
{ , paramètres de
nom sortie et
} : d'entrée/sortie
type
;
...
[
var
]
nom
{,
nom
}:
type

Prev Up

Cours d'Informatique -- 13 Quelques commandes de base des systèmes d'exploitation
Prev Up
Précédent : 12 Référence rapide du langage JavaScript
Remonter : Top
13 Quelques commandes de base des systèmes

d'exploitation
Le système d'exploitation d'un ordinateur met à la disposition du (ou des) utilisateurs les ressources de la machine. Les services d'un système
d'exploitation varient beaucoup du système le plus rudimentaire (DOS - Disk Operating System), aux systèmes les plus sophistiqués (ceux de
la famille Unix/Linux). L'aspect extérieur d'un système est de plus en plus souvent graphique (depuis le système du Macintosh).
Le système de gestion de fichiers
Le premier service, assuré par tous les systèmes d'exploitation, est celui de stockage et de rangement des informations. Les informations sont
rangées dans des fichiers, eux-mêmes rangés dans des dossiers (aussi appelés répertoires), qui peuvent être rangés dans des dossiers ...
Cette structure de rangement "en arbre", est visualisée aisément par les systèmes de gestion de fichiers disposant d'une interface graphique
(voir figure 13).
Exemple de système de gestion de fichiers

Les fichiers et dossiers peuvent être nommés par leur nom :
● absolu, c'est à dire par rapport au dossier principal (noté / pour Unix, \ pour DOS), en notant tous les noms de dossiers jusqu'au fichier
concerné. Par exemple :
/DOSSIERS/UTILISATEURS/MAURAS/COURRIER/ELECTRONIQUE avec Unix ou
\DOSSIERS\UTILISATEURS\MAURAS\COURRIER\ELECTRONIQUE avec DOS.
● relatif au dossier courant. Par exemple, si le dossier courant est :
/DOSSIERS/UTILISATEURS/MAURAS le dossier précédent sera noté : COURRIER/ELECTRONIQUE avec Unix.

Cours d'Informatique -- 13 Quelques commandes de base des systèmes d'exploitation
Pour y accéder en mode commande, ou par programme, il est utile pour manipuler fichiers et répertoires, de connaître les quelques commandes
élémentaires suivantes (voir figure 13).
UNIX COMMANDES PRINCIPALES DOS
ls donne la liste des fichiers et dossiers présents dans le dossier courant dir
pwd indique le dossier courant
cd nomrep change le dossier courant - permet de "descendre" dans le dossier de nom: nomrep cd nomrep
cd .. change le dossier courant - permet de "remonter" dans le dossier au-dessus cd ..
cd permet de "revenir" au dossier initial
mv nomfich1 nomfich2 change le nom du fichier:nomfich1 en: nomfich2 rename nomfich1 nomfich2
cp nomfich1 nomfich2 copie le fichier:nomfich1 en: nomfich2 copy nomfich1 nomfich2
rm nomfich efface le fichier: nomfich (demande confirmation: y ou n) del nomfich
mkdir nomrep crée un dossier dans le dossier courant de nom: nomrep mkdir nomrep
rmdir nomrep efface le dossier: nomrep du dossier courant rmdir nomrep
more nomfich affiche à l'écran le fichier: nomfich type nomfich
Commandes de gestion de fichiers et dossiers (Unix et DOS)
La documentation
Pour les nombreuses autres commandes d'un système d'exploitation particulier, il est recommandé de consulter la documentation disponible le
plus souvent en ligne sur l'ordinateur. Les commandes les plus utiles à connaître sont ainsi celles qui apportent de l'information sur les autres
commandes et les fonctionnalités du système : man pour les systèmes Unix, help pour le système DOS.
Prev Up

Cours d'Informatique -- Syntaxe du langage JavaScript
Up Next
Remonter : 12 Référence rapide du langage JavaScript
Suivant : Interprétation d'un programme JavaScript
Syntaxe du langage JavaScript

La syntaxe présentée ici ne décrit qu'une partie du langage JavaScript. En particulier, on aborde peu les
notions de classes et d'objets. Ces notions sont cependant fondamentales car elles permettent de mettre à
disposition du programmeur de très nombreuses fonctions déjà écrites (par exemple les fonctions de la
classe Math) et de contrôler par programme le comportement du navigateur (par exemple ouvrir une
nouvelle fenêtre - une fenêtre est un "objet" connu de JavaScript).
Pour des informations techniques complètes, on peut consulter la documentation officielle à l'adresse :
http://developer.netscape.com/docs/manuals/javascript.html.
La syntaxe (simplifiée) de JavaScript est présentée ici sous la même forme que celle de Pascal (voir
comment lire une description de syntaxe).
● Syntaxe d'un programme et des instructions
● Syntaxe des expressions
● Syntaxe des déclarations

Up Next

Cours d'Informatique -- Interprétation d'un programme JavaScript
Prev Up
Précédent : Syntaxe du langage JavaScript
Remonter : 12 Référence rapide du langage JavaScript
Interprétation d'un programme JavaScript

Un programme JavaScript peut comporter des déclarations de variables globales et de fonctions. Il doit dans
tous les cas comporter au moins une ou des instructions faisant éventuellement référence aux variables et
fonctions déclarées s'il y en a.
Ce programme est interprété - c'est à dire qu'il est lu ligne après ligne et les instructions sont alors exécutées.
L'interprète du langage JavaScript est intégré au navigateur. Il n'y a pas de phase préalable de compilation
comme pour un programme en langage Pascal. Il n'y a que très peu de vérifications de types, l'interprète étant
capable de s'adapter aux données fournies par l'utilisateur et de voir leurs types au moment de l'exécution.
Pour exécuter un programme JavaScript, il suffit de l'inclure dans une page internet écrite au format HTML.
Heureusement, il n'est nécessaire de connaître que les quelques notions suivantes du format HTML pour
pouvoir écrire et exécuter des programmes JavaScript :
● un fichier HTML commence car <HTML> et se termine par </HTML>
● le corps du texte à afficher commence par <BODY> et se termine par </BODY>
● un programme JavaScript doit être inclus entre les marques :

<script language="JavaScript"> et </script>. Il est alors lu au moment de l'affichage de
la page.
● Pour créer un bouton sur lequel est écrit un mot et qui provoque l'exécution d'une instruction
JavaScript, il suffit d'écrire la ligne suivante
<form><input type='button' value='mot' onClick='instruction'></form>
Dans l'exemple suivant le bouton provoque l'exécution de l'instruction simple () qui démarre l'exécution
de cette fonction.
<HTML><BODY>
<script language="JavaScript">
function simple ()
{ var x
x = prompt('Donner un nombre', 0)
alert('le carre de ' + x + ' est ' + (x*x) )
}
</script>
Pour exécuter le programme cliquer sur le bouton ci-dessous.
<form><input type='button' value='Exécuter' onClick='simple()'></form>
</BODY></HTML>

Cours d'Informatique -- Interprétation d'un programme JavaScript
A la lecture de cette page avec un navigateur internet, la function simple est mémorisée par le navigateur
(elle ne s'affiche pas à l'écran) et le bouton Exécuter s'affiche à l'écran. Au moment ou l'utilisateur clique
sur ce bouton, l'exécution démarre.
En cliquant ici, observer le comportement de la page HTML reproduite ci-dessus.
Prev Up

Up Next
Remonter : Syntaxe du langage JavaScript
Suivant : Syntaxe des expressions
Syntaxe d'un programme et des instructions

::= [ un
Programme Declarations programme
] Javascript
Sequence comporte une
suite de
déclarations
(optionnelles)
et une
séquence
d'instructions
::= Instruction séquence
Sequence ; d'instructions.
... Remarque: le
Instruction point virgule
peut être omis
s'il y a
passage à la
ligne entre
deux
instructions
::= Variable = affectation
Instruction Expression Remarque: il
y a de
nombreux
autres
opérateurs
d'affectation
du type x
+= y qui est
une
abbréviation
de : x = x
+ y

| Variable = lecture de la
prompt(' variable avec
Chaine de affichage de
caractères la chaîne et
', valeur par
Expression défaut
proposée
)
| alert( écriture de
Expression l'expression
) qui doit être
convertible
en chaîne de
caractères
(automatique
pour les
nombres)
| Nom ( appel d'une
Expression fonction
{,
Expression
})
| if ( si ...alors
Expression
)
Instruction
| if ( si ...alors
Expression ...sinon
)
Instruction
else
Instruction
| while ( tant que ...
Expression
)
Instruction
| do répéter
Instruction ...tant que ...
while ( (s'exécute au
Expression moins 1 fois)
)

| for ( permet
Affectation d'écrire une
; boucle :
Expression pour ...
;
Affectation
)
Instruction
| switch ( selon ...
Expression
) {
case
Constante
:
Instruction
; break;
...
case
Constante
:
Instruction
; break;
[ default
:
Instruction
]
}
| { bloc
Sequence d'instructions
}
| return ( utilisé à la
Expression fin d'une
) fonction pour
préciser la
valeur du
résultat de la
fonction
::= suite de nom de
Nom lettres et de fonction
chiffres,
commençant
par une
lettre


Up Next

Prev Up Next
Précédent : Syntaxe d'un programme et des instructions
Suivant : Syntaxe des déclarations
Syntaxe des expressions

::= ( Expression ) entre parenthèses,
Expression pour imposer
l'ordre des calculs
| Expression || ou (pour booléens)
Expression
| Expression && et (pour booléens)
Expression
| Expression === egalité
Expression
| Expression !== différent
Expression
| Expression < inférieur
Expression
| Expression > supérieur
Expression
| Expression <= inférieur ou égal
Expression
| Expression >= supérieur ou égal
Expression
| Expression + addition (pour
Expression nombres)
concaténation(pour
chaines de
caractères)
| Expression - soustraction (pour
Expression nombres)
| Expression * multiplication
Expression (pour nombres)
| Expression / division à résultat
Expression réel(pour nombres)

| Expression % reste de la division

Expression entière
| ! Expression non
| - Expression opposé (pour
nombre)
| Nom ( appel d'une
Expression { , fonction
Expression } )
| Math.abs( valeur absolue
Expression ) (pour nombre)
| Math.pow( élévation à la
Expression , puissance (pour
Expression ) nombres)
| Math.max( maximum (pour
Expression , nombres)
Expression )
| Math.min( minimum (pour
Expression , nombres)
Expression )
| Math.sqrt( racine carrée (pour
Expression ) nombre)
| Math.floor( plus grand entier
Expression ) inférieur à un
nombre donné
| Math.round( arrondi à l'entier le
Expression ) plus proche (pour
un nombre)
| Math.cos( cosinus
Expression )
| Math.sin( sinus
Expression )
| Math.tan( tangente
Expression )
| Math.log( logarithme à base
Expression ) e
| Math.exp( exponentielle
Expression )
| Variable nom d'une variable

| Constante nombre, booléen

ou chaîne de
caractères
REMARQUE : en absence de parenthèses, les opérations binaires les plus prioritaires sont exécutées
d'abord. Dans la règle ci-dessus les opérateurs sont rangés du moins prioritaire au plus prioritaire.
::= suite de nom de
Variable lettres et de la
chiffres, variable
commençant
par une
lettre
| Variable [ élément
Expression d'un
] vecteur
::= [ - ] constante
Constante chiffre { numérique
chiffre } [ Exemples :
. { chiffre 3.1416,
} ] [ e [ - 675,
] chiffre { -23.4e10,
chiffre } ] 45e-12
| true constante
booléenne:
vrai
| false constante
booléenne:
faux
| ' suite de constante
caractères chaîne de
' caractères

Prev Up Next

Prev Up
Précédent : Syntaxe des expressions
Syntaxe des déclarations

::= Declaration liste de
Declarations ... déclarations
Declaration
::= declaration une

Declaration de fonction
fonction
| declaration plusieurs
de variables
variables globales
::= var Nom il n'est pas
Declaration { , Nom } nécessaire
de de déclarer
variables le type des
variables
| var Nom déclaration
= new d'une
Array ( variable
Constante tableau
)
::= function les
Declaration Nom ( declarations
de fonction Parametres de variables
) sont ici
{ locales à la
{ fonction
Declaration
de
variables }
Sequence
}

::= [ la fonction
Parametres Nom "principale"
{ , (celle que
Nom l'utilisateur
} ] appelle) est
souvent une
fonction
sans
paramètre

Prev Up

Cours Univ Nanates

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Univ Nanates

Transféré par

Droits d'auteur :

Formats disponibles

Cours d'Informatique

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours.html (1 of 3) [16-11-2001 19:51:15]

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours.html (2 of 3) [16-11-2001 19:51:15]

© Christophe Mauras, Université de Nantes, 4 octobre 2000

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours.html (3 of 3) [16-11-2001 19:51:15]

Ce cours a bénéficié de l'expérience de toute l'équipe pédagogique d'informatique en Deug Sciences,

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_1.html [16-11-2001 19:51:25]

2 Qu'est ce que l'informatique ?

● 2.2 Communiquer, coder, traiter

© Christophe Mauras, Université de Nantes, 4 octobre 2000

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_2.html [16-11-2001 19:51:30]

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_86.html (1 of 2) [16-11-2001 19:51:34]

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_86.html (2 of 2) [16-11-2001 19:51:34]

© Christophe Mauras, Université de Nantes, 4 octobre 2000

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_10.html [16-11-2001 19:51:37]

2.1 Points de vue

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_3.html [16-11-2001 19:51:41]

2.2 Communiquer, coder, traiter

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_4.html [16-11-2001 19:51:44]

© Christophe Mauras, Université de Nantes, 4 octobre 2000

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_5.html [16-11-2001 19:51:47]

2.4 Algorithmes, programmes et langages

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_7.html (1 of 2) [16-11-2001 19:51:50]

Pour un tour d'horizon des langages de programmation, on visitera la tour de Babel.

© Christophe Mauras, Université de Nantes, 4 octobre 2000

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_7.html (2 of 2) [16-11-2001 19:51:50]

● Les différentes composantes de la mémoire et leur capacité

● Les différentes unités de communication

❍ Intel Pentium III à 450 MHz

❍ Chipset PCI Intel 440BX, bus système à 100 MHz

❍ 64 Mo de mémoire (SDRAM 100MHz) extensible à 384 Mo (3 emplacements DIMM)

❍ 512 Ko de mémoire cache intégrée au processeur

❍ Contrôleur EIDE Ultra DMA (33 Mo/s) intégré

❍ Disque dur 6,4 Go SMART II

❍ Unité de disquette 3" - 1,44 Mo

❍ Chipset réseau Ethernet PCI 3COM 3C916 - 10/100 MB intégré - RJ 45

❍ 1 slot ISA, 1 slot PCI , 1 slot partagé ISA/PCI

❍ Chipset son Crystal CS4236-B intégré

❍ Lecteur de CD-ROM 17/40x IDE

❍ Contrôleur vidéo avec 4 Mo de mémoire vidéo SGRAM à 100 MHz extensible à 8 Mo

❍ Moniteur couleur 17"

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_9.html (1 of 2) [16-11-2001 19:51:56]

Exercice 2.2 : Capacité mémoire et débits

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_9.html (2 of 2) [16-11-2001 19:51:56]

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_19.html (1 of 2) [16-11-2001 19:51:59]

● 4.2 Programmer avec différents types d'informations

© Christophe Mauras, Université de Nantes, 4 octobre 2000

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_19.html (2 of 2) [16-11-2001 19:51:59]

● 5.2 Un exemple de traitement générique : le tableur

© Christophe Mauras, Université de Nantes, 4 octobre 2000

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_26.html [16-11-2001 19:52:02]

procédure permettant à un utilisateur de se mettre en relation avec un système informatique et, si

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_88.html (1 of 2) [16-11-2001 19:52:06]

Toile d'araignée mondiale :

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_88.html (2 of 2) [16-11-2001 19:52:06]

Architecture d'un ordinateur

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_6.html (1 of 2) [16-11-2001 19:52:11]

❍ Divers dispositifs de grande capacité, destinés à la sauvegarde périodique de toutes les

❍ En sortie, vers l'utilisateur : écran, imprimante, table traçante ...

http://www.sciences.univ-nantes.fr/info/enseignement/deug/STPI/stpi1/cours_6.html (2 of 2) [16-11-2001 19:52:11]

8.2 La tour de Babel

❍ des langages dédiés aux applications de calcul scientifique dont FORTRAN,

❍ des langages d'usage général dont Pascal, C, ADA ...