Académique Documents
Professionnel Documents
Culture Documents
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é
❍ Exercices
❍ Corrigés et indications
● 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
❍ Corrigés et indications
● 6 Commencer à programmer
❍ 6.1 Traitements conditionnels
❍ Exercices
❍ Corrigés et indications
❍ 6.2 Traitements répétitifs
❍ Exercices
❍ Corrigés et indications
❍ 6.3 Traitements de tableaux
❍ Exercices
❍ Corrigés et indications
● 7 Pour bien programmer
❍ 7.1 Décomposer les traitements
❍ 7.2 Fonctions et procédures
❍ Exercices
❍ Corrigés et indications
❍ 7.3 Analyser les traitements répétitifs
❍ Exercices
❍ Corrigés et indications
● 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
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
Prev Up Next
Précédent : 1 Introduction
Remonter : Top
Suivant : 3 Communiquer de l'information
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.
[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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
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
Up Next
Remonter : 2 Qu'est ce que l'informatique ?
Suivant : 2.2 Communiquer, coder, traiter
Prev Up Next
Précédent : 2.1 Points de vue
Remonter : 2 Qu'est ce que l'informatique ?
Suivant : 2.3 L'ordinateur
● 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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : 2.2 Communiquer, coder, traiter
Remonter : 2 Qu'est ce que l'informatique ?
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
Précédent : 2.3 L'ordinateur
Remonter : 2 Qu'est ce que l'informatique ?
Suivant : Exercices
● 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.
Prev Up
Précédent : 2.4 Algorithmes, programmes et langages
Remonter : 2 Qu'est ce que l'informatique ?
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
Ordinateur personnel :
● Composants
● Mémoire
● Stockage
● Réseau
● Connecteurs
❍ 1 port parallèle (ECP), 2 ports série, 1 port souris et 1 port clavier PS/2, 2 ports USB
● Multimédia
● Affichage
● Divers
❍ Clavier 105 touches français
❍ Souris
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 !
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
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
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 :
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.
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
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Up
Remonter : 2.3 L'ordinateur
● 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é.
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)
❍ 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) ....
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Up
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
❍ 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
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
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,
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.
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Up
Up Next
Remonter : 3 Communiquer de l'information
Suivant : 3.2 Communication entre ordinateurs : les réseaux
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Up Next
Prev Up Next
Précédent : 3.1 Communication homme-machine
Remonter : 3 Communiquer de l'information
Suivant : 3.3 Programmer la communication
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
● 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)
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
Précédent : 3.2 Communication entre ordinateurs : les réseaux
Remonter : 3 Communiquer de l'information
Suivant : Exercices
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
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
Précédent : 3.3 Programmer la communication
Remonter : 3 Communiquer de l'information
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.
Prev Up
Précédent : Exercices
Remonter : 3 Communiquer de l'information
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)
}
Pour executer ce programme JavaScript
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
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up
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
Prev Up Next
Précédent : Internet
Remonter : 3.2 Communication entre ordinateurs : les réseaux
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é.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up
Précédent : Le courrier électronique
Remonter : 3.2 Communication entre ordinateurs : les réseaux
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up
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
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 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 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,
Parmi les représentations possibles des (de certains) nombres réels, la plus courante consiste à utiliser un
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Up Next
Prev Up Next
Précédent : 4.1 Codages
Remonter : 4 Représenter l'information
Suivant : 4.3 Fichiers et formats
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
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.
var revenu ;
var nbparts ;
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : 4.2 Programmer avec différents types d'informations
Remonter : 4 Représenter l'information
Suivant : 4.4 Enjeux de société
● 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
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : 4.3 Fichiers et formats
Remonter : 4 Représenter l'information
Suivant : Exercices
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
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,
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : 4.4 Enjeux de société
Remonter : 4 Représenter l'information
Suivant : Corrigés et indications
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
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 :
program precision;
var x,y :real;
begin
x := 0.7;
y := 0.3;
writeln ('0.3 + 0.7 = ', x + y)
end.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up
Précédent : Exercices
Remonter : 4 Représenter l'information
Corrigés et indications
Exercice 4.1
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
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up
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
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
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.
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'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
Précédent : 10 Informations sur quelques logiciels d'usage courant
Remonter : Top
Suivant : 12 Référence rapide du langage JavaScript
● Déclarations et types
● Compilation et exécution
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
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
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
● Corrigés et indications
● 6.2 Traitements répétitifs
● Exercices
● Corrigés et indications
● 6.3 Traitements de tableaux
● Exercices
● Corrigés et indications
Up Next
Remonter : 5 Traiter l'information
Suivant : 5.2 Un exemple de traitement générique : le tableur
● Le choix
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
"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.
Exemple :
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Up Next
Prev Up Next
Précédent : 5.1 Un exemple : le traitement de texte
Remonter : 5 Traiter l'information
Suivant : 5.3 Programmer
Exemple de tableur
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).
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : 5.3 Programmer
Remonter : 5 Traiter l'information
Suivant : Corrigés et indications
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... }
identificateur type rôle
x entier demandé à l'utilisateur
y entier demandé à l'utilisateur
début
6
7
8
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,
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
● effectue une permutation circulaire à droite des contenus de ces trois variables et enfin
Prev Up
Précédent : Exercices
Remonter : 5 Traiter l'information
Corrigés et indications
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
début
Exercice 5.3
début
Prev Up
Prev Up Next
Précédent : Syntaxe d'un programme et des instructions
Remonter : Syntaxe
Suivant : Syntaxe des déclarations
| 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
● ensuite : +, -, or
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
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'
Up Next
Remonter : 5.3 Programmer
Suivant : De l'algorithme au programme Pascal ou JavaScript
● 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 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) :
début
Prev Up
Précédent : Ecriture d'un algorithme
Remonter : 5.3 Programmer
Une séquence d'instructions est une liste d'instructions séparées par des point-virgules.
instruction ;
...
instruction
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 }
variable := expression
readln( variable { , variable } )
writeln( expression { , expression } )
Et en JavaScript :
Variable = Expression
Variable = prompt(' Chaine de caractères ', Expression )
alert( Expression )
Prev Up Next
Précédent : 6 Commencer à programmer
Remonter : Top
Suivant : 8 Pour aller plus loin
Up Next
Remonter : 6 Commencer à programmer
Suivant : Exercices
Pour résoudre des problèmes plus complexes (plus de 2 cas), on peut de plus :
● composer entre elles ces constructions,
● 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
● De l'algorithme au programme Pascal ou JavaScript
Prev Up Next
Précédent : 6.1 Traitements conditionnels
Remonter : 6 Commencer à programmer
Suivant : Corrigés et indications
Exercices
Les algorithmes demandés pourront être traduits en Pascal ou en JavaScript en suivant la syntaxe donnée en annexe.
début
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
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,
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.
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 ?
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : Exercices
Remonter : 6 Commencer à programmer
Suivant : 6.2 Traitements répétitifs
Corrigés et indications
Exercice 6.1
Ligne x y z
DEBUT
Exercice 6.2
début
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
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
Exercice 6.5
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : Corrigés et indications
Remonter : 6 Commencer à programmer
Suivant : Exercices
● 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
● De l'algorithme au programme Pascal ou JavaScript
Prev Up Next
Précédent : 6.2 Traitements répétitifs
Remonter : 6 Commencer à programmer
Suivant : Corrigés et indications
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 }
identificateur type rôle
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) :
Prev Up Next
Précédent : Exercices
Remonter : 6 Commencer à programmer
Suivant : 6.3 Traitements de tableaux
Corrigés et indications
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 }
identificateur type rôle
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
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 '-'.
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.
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 }
identificateur type rôle
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
début
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
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
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : Corrigés et indications
Remonter : 6 Commencer à programmer
Suivant : Exercices
● Définition
● Remplissage d'un tableau
● Traitement élémentaire et affichage
● Tri d'un tableau
● De l'algorithme au programme Pascal ou JavaScript
Prev Up Next
Précédent : 6.3 Traitements de tableaux
Remonter : 6 Commencer à programmer
Suivant : Corrigés et indications
Exercices
Les algorithmes demandés pourront être traduits en Pascal ou en JavaScript en suivant la syntaxe donnée
en annexe.
Exercice 6.11 : Manipulation d'un vecteur
Simuler le fonctionnement de l'algorithme suivant :
Algorithme ExempleVecteur
{ Sans commentaire }
identificateur type rôle
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.
]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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up
Précédent : Exercices
Remonter : 6 Commencer à programmer
Corrigés et indications
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 }
identificateur type rôle
n entier à convertir
i entier indice de parcours
code vecteur [0..31] d'entiers pour mémoriser le code
début
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 }
identificateur type rôle
P tableau de 0 à 100 de réels on limite au degré 100
i entier indice pour parcourir le tableau
début
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
● 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 }
identificateur type rôle
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
sinon si mesure <= 6 alors i <- 3
sinon si mesure <= 8 alors i <- 4
sinon si mesure <= 10 alors i <- 5
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 }
identificateur type rôle
TableauValeurs tableau de 1 à ... de ... tableau des valeurs saisies
i entier indice pour parcourir le tableau
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
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 }
identificateur type rôle
a réel le coefficient a, donné par l'utilisateur
b réel le coefficient b, donné par l'utilisateur
début
Prev Up Next
Précédent : Exemple introductif
Remonter : 6.1 Traitements conditionnels
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
Précédent : La construction conditionnelle
Remonter : 6.1 Traitements conditionnels
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
...
dont le fonctionnement est le suivant :
● l'expression booléenne est tout d'abord calculée,
● 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
alors ecrire ('la solution est ', b/a)
sinon ecrire ('je ne sais pas faire')
fin si
...
Pour executer la traduction de cet algorithme en JavaScript
Prev Up Next
Précédent : La construction alternative
Remonter : 6.1 Traitements conditionnels
Suivant : Utilisation d'opérations booléennes
...
si a <> 0
alors ecrire ('la solution est ', b/a)
sinon si b = 0
alors ecrire ('Tout x est solution')
sinon ecrire ('Pas de solution')
fin si
fin si
...
Pour executer la traduction de cet algorithme en JavaScript
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).
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : Composition de ces constructions
Remonter : 6.1 Traitements conditionnels
Suivant : Quelques équivalences entre constructions
...
si a <> 0
alors ecrire ('la solution est ', b/a)
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
...
Pour executer la traduction de cet algorithme en JavaScript
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
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é".
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : Utilisation d'opérations booléennes
Remonter : 6.1 Traitements conditionnels
Suivant : Choix selon des valeurs énumérées
Prev Up Next
Précédent : Quelques équivalences entre constructions
Remonter : 6.1 Traitements conditionnels
Suivant : De l'algorithme au programme Pascal ou JavaScript
...
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
...
dont le fonctionnement est le suivant :
● 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')
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up
Précédent : Choix selon des valeurs énumérées
Remonter : 6.1 Traitements conditionnels
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up
Up Next
Remonter : 6.2 Traitements répétitifs
Suivant : La construction : Répéter
...
tant que expression booléenne
instruction 1
instruction 2
...
fin tant que
...
dont le fonctionnement est le suivant :
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 }
identificateur type rôle
Montant réel le montant de l'épargne
NombreAnnees entier le résultat cherché
début
fin
L'exécution de cet algorithme donne le résultat suivant :
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".
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Up Next
Prev Up Next
Précédent : La construction : Tant que
Remonter : 6.2 Traitements répétitifs
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
dont le fonctionnement est le suivant :
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
Algorithme EpargneBis
{ Calcule le nombre d'années nécessaire pour doubler son épargne }
identificateur type rôle
Montant réel le montant de l'épargne
NombreAnnees entier le résultat cherché
début
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".
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : La construction : Répéter
Remonter : 6.2 Traitements répétitifs
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
...
dont le fonctionnement est le suivant :
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 }
identificateur type rôle
Montant réel le montant de l'épargne
NombreAnnees entier le compteur
début
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 :
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 :
Prev Up Next
Précédent : La construction : Pour
Remonter : 6.2 Traitements répétitifs
Suivant : De l'algorithme au programme Pascal ou JavaScript
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é')
Pour executer la traduction de cet algorithme en JavaScript
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 }
identificateur type rôle
MontantEnFrancs réel une variable pour les montants successifs en francs
début
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 }
identificateur type rôle
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
Prev Up
Précédent : Exemples de traitements répétitifs
Remonter : 6.2 Traitements répétitifs
et en JavaScript :
while ( Expression )
Instruction
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
En JavaScript, la traduction de la construction pour est possible, par une instruction plus générale :
for ( Affectation ; Expression ; Affectation )
Instruction
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 }
identificateur type rôle
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
TableauMesures[1], TableauMesures[2], TableauMesures[3]...Il ne reste plus qu'à consulter l'ensemble de ces variables
pour faire les calculs souhaités.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Up Next
Prev Up Next
Précédent : Exemple introductif
Remonter : 6.3 Traitements de tableaux
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].
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 :
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : Définition
Remonter : 6.3 Traitements de tableaux
Suivant : Traitement élémentaire et affichage
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
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 }
identificateur type rôle
TableauValeurs tableau de 1 à ... de ... tableau des valeurs saisies
i entier indice pour parcourir le tableau
nombre entier nombre de valeurs à saisir
début
Prev Up Next
Précédent : Remplissage d'un tableau
Remonter : 6.3 Traitements de tableaux
Suivant : Tri d'un tableau
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 }
identificateur type rôle
TableauValeurs tableau de 1 à ... de ... tableau des valeurs saisies
i entier indice pour parcourir le tableau
nombre entier nombre de valeurs saisies
début
Prev Up Next
Précédent : Traitement élémentaire et affichage
Remonter : 6.3 Traitements de tableaux
Suivant : De l'algorithme au programme Pascal ou JavaScript
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 }
identificateur type rôle
TableauValeurs tableau de 1 à ... de ... tableau des valeurs saisies
Ainserer ... valeur à insérer
i entier indice pour parcourir le tableau
place entier indice indiquant la place où insérer
nombre entier nombre de valeurs saisies
début
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up
Précédent : Tri d'un tableau
Remonter : 6.3 Traitements de tableaux
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 Next
Précédent : 7 Pour bien programmer
Remonter : Top
Suivant : 9 En conclusion
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
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,
Voici un exemple d'exécution possible (sont notées en gras les données fournies par l'utilisateur) :
● répétition de la demande de nombres à l'utilisateur jusqu'à ce qu'il en propose un qui soit premier.
Up Next
Remonter : 7 Pour bien programmer
Suivant : 7.2 Fonctions et procédures
Prev Up Next
Précédent : 7.1 Décomposer les traitements
Remonter : 7 Pour bien programmer
Suivant : Exercices
● 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,
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
Prev Up Next
Précédent : 7.2 Fonctions et procédures
Remonter : 7 Pour bien programmer
Suivant : Corrigés et indications
Exercices
Les algorithmes demandés pourront être traduits en Pascal ou en JavaScript en suivant la syntaxe donnée
en annexe.
Exercice 7.1 : Simulation d'un programme Pascal avec des procédures
Soit le programme Pascal suivant :
program q;
● 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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : Exercices
Remonter : 7 Pour bien programmer
Suivant : 7.3 Analyser les traitements répétitifs
Corrigés et indications
Exercice 7.1
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 }
identificateur type rôle
ENTREE LPieds entier donnée
ENTREE Lpouces entier donnée
SORTIE LMetres réel résultat
LOCALE TotalEnPouces entier calcul intermédiaire
début
fin
Algorithme MetresEnPiedsPouces
{ Convertit une longueur exprimée en mètres en une longueur équivalente en pieds et pouces }
identificateur type rôle
ENTREE LMetres réel donnée
SORTIE LPieds entier résultat
SORTIE Lpouces entier résultat
LOCALE TotalEnPouces entier calcul intermédiaire
début
début
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.
{
prises = Saisie (Allumettes, joueur)
Allumettes = Allumettes - prises
if (joueur === 1)
joueur = 2
else joueur = 1
}
alert ('le joueur ' + joueur + ' a gagné !')
Pour executer ce programme JavaScript
Prev Up Next
Précédent : Corrigés et indications
Remonter : 7 Pour bien programmer
Suivant : Exercices
● 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
Prev Up Next
Précédent : 7.3 Analyser les traitements répétitifs
Remonter : 7 Pour bien programmer
Suivant : Corrigés et indications
Exercices
Les algorithmes demandés pourront être traduits en Pascal ou en JavaScript en suivant la syntaxe donnée
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
var x,p
Prev Up
Précédent : Exercices
Remonter : 7 Pour bien programmer
Corrigés et indications
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
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
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 }
identificateur type rôle
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 :
Algorithme AfficherCarres2
{ 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.
Algorithme AfficherCarres3
{ 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
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up
Up Next
Remonter : 7.1 Décomposer les traitements
Suivant : Une première solution
● 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 }
identificateur type rôle
nombre entier le nombre demandé
premier booléen vrai ssi nombre est premier
début
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
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.
Prev Up
Précédent : Analyse descendante de l'exemple
Remonter : 7.1 Décomposer les traitements
début
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up
Up Next
Remonter : 7.2 Fonctions et procédures
Suivant : Une solution structurée pour le problème des nombres premiers
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 }
identificateur type rôle
ENTREE n,m entiers les parametres
début
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
----------
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
début
HighestScore <- 0
MeilleurScore(12,14,HighestScore,BestPlayer)
ecrire(HighestScore,BestPlayer) { 14 2 }
MeilleurScore(13,11,HighestScore,BestPlayer)
ecrire(HighestScore,BestPlayer) { 14 1 }
MeilleurScore(15,17,HighestScore,BestPlayer)
ecrire(HighestScore,BestPlayer) { 17 2 }
MeilleurScore(14,9,HighestScore,BestPlayer)
ecrire(HighestScore,BestPlayer) { 17 1 }
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 :
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 }
identificateur type rôle
ENTREE score1, score2 entiers scores des joueurs 1 et 2
SORTIE entier le maximum
début
Prev Up Next
Précédent : Exemples simples de procédures et de fonctions
Remonter : 7.2 Fonctions et procédures
Suivant : De l'algorithme au programme Pascal ou JavaScript
début
Algorithme LireEntierStrictementPositif
{ Saisie d'un nombre strictement positif }
identificateur type rôle
SORTIE n entier le nombre saisi
début
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 }
identificateur type rôle
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 }
identificateur type rôle
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
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é.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up Next
Précédent : Une solution structurée pour le problème des nombres premiers
Remonter : 7.2 Fonctions et procédures
Suivant : Traduction de la solution structurée en Pascal
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 } )
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
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 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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up
Précédent : De l'algorithme au programme Pascal ou JavaScript
Remonter : 7.2 Fonctions et procédures
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
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,
Prev Up Next
Précédent : Introduction
Remonter : 7.3 Analyser les traitements répétitifs
Suivant : Pour choisir un bon schéma
début
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 }
début
pour i de 1 à N
obtenir ieme information
traiter ieme information
fin pour
fin
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up
Précédent : Des schémas standards
Remonter : 7.3 Analyser les traitements répétitifs
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).
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Up Next
Remonter : 8 Pour aller plus loin
Suivant : 8.2 La tour de Babel
● 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 :
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Up Next
Prev Up
Précédent : 8.2 La tour de Babel
Remonter : 8 Pour aller plus loin
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],
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
Précédent : Glossaire
Remonter : Top
Suivant : 10 Informations sur quelques logiciels d'usage courant
A Annexes
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
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.
● à 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.
● 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).
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
Prev Up Next
Précédent : Syntaxe
Remonter : 11 Référence rapide du langage Pascal
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up Next
Prev Up
Précédent : Déclarations et types
Remonter : 11 Référence rapide du langage Pascal
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up
Up Next
Remonter : Syntaxe
Suivant : Syntaxe d'un programme et des instructions
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 ,
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 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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Up Next
Prev Up Next
Précédent : Comment lire une description de syntaxe
Remonter : Syntaxe
Suivant : Syntaxe des expressions
| 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
Précédent : Syntaxe des expressions
Remonter : Syntaxe
Prev Up
Prev Up
Précédent : 12 Référence rapide du langage JavaScript
Remonter : Top
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).
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up
Up Next
Remonter : 12 Référence rapide du langage JavaScript
Suivant : Interprétation d'un programme JavaScript
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
Prev Up
Précédent : Syntaxe du langage JavaScript
Remonter : 12 Référence rapide du langage JavaScript
<HTML><BODY>
<script language="JavaScript">
function simple ()
{ var x
x = prompt('Donner un nombre', 0)
alert('le carre de ' + x + ' est ' + (x*x) )
}
</script>
</BODY></HTML>
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.
© Christophe Mauras, Université de Nantes, 4 octobre 2000
Prev Up
Up Next
Remonter : Syntaxe du langage JavaScript
Suivant : Syntaxe des expressions
| 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
Prev Up Next
Précédent : Syntaxe d'un programme et des instructions
Remonter : Syntaxe du langage JavaScript
Suivant : Syntaxe des déclarations
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
Précédent : Syntaxe des expressions
Remonter : Syntaxe du langage JavaScript
::= [ la fonction
Parametres Nom "principale"
{ , (celle que
Nom l'utilisateur
} ] appelle) est
souvent une
fonction
sans
paramètre