tronc commun algo/algo approfondie
This commit is contained in:
gwen
parent
ca7c2df715
commit
9a03e5190d
|
|
@ -1,291 +1 @@
|
||||||
Algorithmique
|
.. include:: ../../tronCommun/algo.txt
|
||||||
=============
|
|
||||||
|
|
||||||
Al-Kharezmi, auteur du traité "Kitab al jabr w'al-muqabala", est l'inventeur
|
|
||||||
des manipulations algébriques (algèbre = **al jabr**).
|
|
||||||
C'est Léonard de Pise, dit Fibonacci, qui emprunta le nom du célèbre
|
|
||||||
mathématicien arabe du 9ème siècle, mais l'algèbre existe
|
|
||||||
depuis bien plus longtemps (Depuis Babylone, puis ensuite l'Egypte ancienne).
|
|
||||||
|
|
||||||
.. glossary::
|
|
||||||
|
|
||||||
|
|
||||||
algorithme
|
|
||||||
|
|
||||||
terme désignant une suite d'opérations constituant un schéma de calcul
|
|
||||||
ou de résolution d'un problème. C'est un processus systématique de
|
|
||||||
résolution d'un problème permettant de décrire précisément des étapes.
|
|
||||||
C'est une suite finie d'instructions permettant de donner la réponse à un
|
|
||||||
problème.
|
|
||||||
|
|
||||||
L'algorithmique est l'étude et la production de règles et de techniques
|
|
||||||
qui sont impliquées dans la définition d'algorithmes.
|
|
||||||
|
|
||||||
Implémentation d'un algorithme
|
|
||||||
------------------------------
|
|
||||||
|
|
||||||
.. glossary::
|
|
||||||
|
|
||||||
implémentation
|
|
||||||
|
|
||||||
Adaptation de la méthodologie de calculabilité au calcul effectif
|
|
||||||
sur une machine abstraite ou via un langage formel.
|
|
||||||
|
|
||||||
Il n’y a pas de parcours à sens unique de l’algorithme vers l’implantation.
|
|
||||||
La quête d’une implantation efficace nous amène souvent à effectuer
|
|
||||||
un retour vers les algorithmes eux-mêmes, et à en modifier des points
|
|
||||||
essentiels. L’aspect théorique de réflexion sur les algorithmes,
|
|
||||||
et l’aspect pratique de l'implémentation sont donc en symbiose.
|
|
||||||
|
|
||||||
Un existant émerge de la décomposition structurale d'un
|
|
||||||
domaine de base. Le fait essentiel, c'est la genèse des genres de l'existant les
|
|
||||||
uns à partir des autres.
|
|
||||||
|
|
||||||
L'essence d'une forme (un algorithme) se réalise au sein d'une matière qu'elle créée
|
|
||||||
(un langage). L'origine d'une matière fait naître les formes (concepts)
|
|
||||||
que sa structure dessine.
|
|
||||||
|
|
||||||
- Notion structurale de non-contradiction
|
|
||||||
- Notion extensive de "réalisation dans un champ donné"
|
|
||||||
|
|
||||||
Deux aspects réciproques : l'essence d'une forme se réalise au sein d'une
|
|
||||||
matière qu'elle crée, l'essence d'une matière faisant naître les formes que sa
|
|
||||||
structure dessine.
|
|
||||||
|
|
||||||
Abandonner l'idée trop simpliste de domaines concrets et d'opérations abstraites
|
|
||||||
qui posséderaient en eux-mêmes comme une nature de matière et une nature de
|
|
||||||
forme ; cette conception tendrait, en effet, à stabiliser les existants
|
|
||||||
mathématiques dans certains rôles immuables et ignorerait le fait que les
|
|
||||||
existants abstraits qui naissent de la structure d'un domaine plus concret
|
|
||||||
peuvent à leur tour servir de domaine de base pour la genèse d'autres existants.
|
|
||||||
|
|
||||||
L'algorithme comme généralisation de la calculabilité
|
|
||||||
------------------------------------------------------
|
|
||||||
|
|
||||||
L'importance croissante de l'informatique comme outil scientifique
|
|
||||||
impose d'élaborer un nouveau mode de description des méthodes de calcul (appelées algorithmes)
|
|
||||||
susceptible de satisfaire à la fois le critère de sécurité (maîtrise du résultat) et la possibilité
|
|
||||||
d'implémenter les calculs sur un ordinateur.
|
|
||||||
|
|
||||||
Exemple d'algorithme
|
|
||||||
---------------------
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
\begin{algorithm}
|
|
||||||
\caption{L'alorithme de Bellman-Kalaba}
|
|
||||||
\begin{algorithmic}[1]
|
|
||||||
\Procedure {BellmanKalaba}{$G$, $u$, $l$, $p$}
|
|
||||||
\ForAll {$v \in V(G)$}
|
|
||||||
\State $l(v) \leftarrow \infty$
|
|
||||||
\EndFor
|
|
||||||
\State $l(u) \leftarrow 0$
|
|
||||||
\Repeat
|
|
||||||
\For {$i \leftarrow 1, n$}
|
|
||||||
\State $min \leftarrow l(v_i)$
|
|
||||||
\For {$j \leftarrow 1, n$}
|
|
||||||
\If {$min > e(v_i, v_j) + l(v_j)$}
|
|
||||||
\State $min \leftarrow e(v_i, v_j) + l(v_j)$
|
|
||||||
\State $p(i) \leftarrow v_j$
|
|
||||||
\EndIf
|
|
||||||
\EndFor
|
|
||||||
\State $l(i) \leftarrow min$
|
|
||||||
\EndFor
|
|
||||||
\State $changed \leftarrow l \not= l’$
|
|
||||||
\State $l \leftarrow l$
|
|
||||||
\Until{$\neg changed$}
|
|
||||||
\EndProcedure
|
|
||||||
\Statex
|
|
||||||
\Procedure {FindPathBK}{$v$, $u$, $p$}
|
|
||||||
\If {$v = u$}
|
|
||||||
\State \textbf{Write} $v$
|
|
||||||
\Else
|
|
||||||
\State $w \leftarrow v$
|
|
||||||
\While {$w \not= u$}
|
|
||||||
\State \textbf{Write} $w$
|
|
||||||
\State $w \leftarrow p(w)$
|
|
||||||
\EndWhile
|
|
||||||
\EndIf
|
|
||||||
\EndProcedure
|
|
||||||
\end{algorithmic}
|
|
||||||
\end{algorithm}
|
|
||||||
|
|
||||||
Exemple d'algorithme avec son implémentation
|
|
||||||
---------------------------------------------
|
|
||||||
|
|
||||||
Soit l'algorithme de factorielle suivant,
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
\begin{algorithm}
|
|
||||||
\caption{Algorithme de la factorielle d'un nombre}\label{factorielle}
|
|
||||||
\begin{algorithmic}[1]
|
|
||||||
\Function{factorielle}{$n$}\Comment{La fonction récursive factorielle}
|
|
||||||
\BState \emph{parametre} : $n$ entier
|
|
||||||
\If{$n = 1$}
|
|
||||||
\BState \emph{Sortie} : 1
|
|
||||||
\Else
|
|
||||||
\BState \emph{Sortie} : $n * \Call{factorielle}{n-1}$ \Comment{On appelle la fonction dans l'algorithme lui-même}
|
|
||||||
\EndIf
|
|
||||||
\EndFunction
|
|
||||||
\end{algorithmic}
|
|
||||||
\end{algorithm}
|
|
||||||
|
|
||||||
et son implémentation en python :
|
|
||||||
|
|
||||||
.. literalinclude:: code/factorielle.py
|
|
||||||
:language: python
|
|
||||||
|
|
||||||
En voici une autre implémentation (en OCaml) :
|
|
||||||
|
|
||||||
.. literalinclude:: code/factorielle.ml
|
|
||||||
:language: ocaml
|
|
||||||
|
|
||||||
On remarque que le **pseudocode** est très proche de
|
|
||||||
la syntaxe du python :
|
|
||||||
|
|
||||||
.. function:: factorielle(n:int)
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
if n=1
|
|
||||||
return 1
|
|
||||||
else
|
|
||||||
return n * factorielle(n-1)
|
|
||||||
end if
|
|
||||||
|
|
||||||
Qualité d'un algorithme
|
|
||||||
-----------------------
|
|
||||||
|
|
||||||
- correction d'un algorithme
|
|
||||||
- complétude d'un algorithme
|
|
||||||
|
|
||||||
Sémantique
|
|
||||||
|
|
||||||
Étude du sens, de la signification d'un langage
|
|
||||||
Définir la sémantique d’un langage formel consiste à lui donner une
|
|
||||||
signification mathématique.
|
|
||||||
|
|
||||||
Sémantique opérationnelle
|
|
||||||
|
|
||||||
on définit la sémantique par sa mise en œuvre sur
|
|
||||||
une machine abstraite.
|
|
||||||
|
|
||||||
Sémantique dénotationnelle
|
|
||||||
|
|
||||||
on associe à chaque construction syntaxique un
|
|
||||||
objet mathématique
|
|
||||||
|
|
||||||
Sémantique axiomatique
|
|
||||||
|
|
||||||
chaque construction est décrite par la manière dont
|
|
||||||
elle transforme des propriétés ou des prédicats.
|
|
||||||
|
|
||||||
Proposition
|
|
||||||
|
|
||||||
une proposition est un énoncé qui est soit vrai, soit faux
|
|
||||||
|
|
||||||
**exemple** : ``2 + 3 = 5``. Proposition vraie.
|
|
||||||
|
|
||||||
Prédicats
|
|
||||||
|
|
||||||
Une proposition dont la valeur de vérité dépend de la valeur d’une ou plusieurs variables
|
|
||||||
|
|
||||||
**Exemple** : ``n est pair`` : vrai pour n = 4 mais faux pour n = 9
|
|
||||||
|
|
||||||
|
|
||||||
Axiome
|
|
||||||
|
|
||||||
une proposition qui est supposée vraie
|
|
||||||
|
|
||||||
Un ensemble d’axiomes est consistant s’il n’existe pas de proposition
|
|
||||||
dont on peut démontrer qu’elle est à la fois vraie et fausse.
|
|
||||||
|
|
||||||
Un ensemble d’axiomes est complet si, pour toute proposition, il est
|
|
||||||
possible de démontrer qu’elle est vraie ou fausse.
|
|
||||||
|
|
||||||
Théorème d’incomplétude de Gödel (1931) : tout ensemble
|
|
||||||
consistant d’axiomes pour l’arithmétique sur les entiers est
|
|
||||||
nécessairement incomplet.
|
|
||||||
|
|
||||||
**Les concepts de base en algorithmique sont les axiomes**
|
|
||||||
|
|
||||||
inférence
|
|
||||||
|
|
||||||
règles d’inférence, règles permettant de combiner des axiomes et des
|
|
||||||
propositions vraies pour établir de nouvelles propositions vraies.
|
|
||||||
|
|
||||||
Démonstration
|
|
||||||
|
|
||||||
vérification d’une proposition par une séquence de déductions logiques
|
|
||||||
à partir d’un ensemble d’axiomes.
|
|
||||||
|
|
||||||
Lorsque le champ donné (le domaine) ne contient qu'un nombre fini d'individus,
|
|
||||||
on peut définir un choix de valeur des variables permettant de vérifier la
|
|
||||||
proposition obtenue par la *conjonction* de tous les axiomes du système proposé.
|
|
||||||
On dit alors que ce choix *réalise* un système d'axiomes.
|
|
||||||
|
|
||||||
|
|
||||||
Il ne s'agit plus de savoir si la définition entraîne l'existence, mais de
|
|
||||||
chercher si la structure d'un système d'axiomes (*règles*) peut donner naissance
|
|
||||||
à un champ d'individus qui soutiennent entre eux les relations définies pas les
|
|
||||||
axiomes.
|
|
||||||
|
|
||||||
Concret et abstrait
|
|
||||||
--------------------
|
|
||||||
|
|
||||||
Il est possible qu'un même genre d'existant joue dans un schéma de genèse le
|
|
||||||
rôle d'abstrait par rapport à un concret de base, et soit au contraire dans une
|
|
||||||
autre genèse le concret de base d'un nouvel abstrait.
|
|
||||||
|
|
||||||
Une pareille présentation des choses implique un tel renversement par rapport
|
|
||||||
aux habitudes de pensée classiques, qu'il faut encore insister sur le sens
|
|
||||||
nouveau que reçoivent ici les expressions de "concret" et "d'abstrait".
|
|
||||||
|
|
||||||
Les systèmes d'axiomes sont souvent conçus comme des structures purement
|
|
||||||
formelles, abstraites. Ces structures sont si profondément engagées dans la
|
|
||||||
genèse de leurs réalisations, qu'il valait mieux désigner par ces termes les
|
|
||||||
structures de base.
|
|
||||||
|
|
||||||
Un système d'axiome *peut* devenir le concret de base.
|
|
||||||
|
|
||||||
Ceci permet d'exprimer non seulement l'engagement du concret dans la genèse de
|
|
||||||
l'abstrait, mais encore les relations d'imitation qui peuvent exister entre la
|
|
||||||
structure de cet abstrait et celle du concret de base.
|
|
||||||
|
|
||||||
Dans certains cas, la genèse de l'abstrait à partir d'un concret de base
|
|
||||||
s'affirme jusqu'à réaliser une imitation de structure entre ces genres
|
|
||||||
d'existants qui naissent l'un de l'autre.
|
|
||||||
|
|
||||||
**C'est pourquoi on représente souvent un algorithme en pseudo-code**,
|
|
||||||
c'est-à-dire en fait dans le mode de représentation (issu du langage préféré de la
|
|
||||||
personne qui l'exprime) dominant chez la personne qui exprime un algorithme.
|
|
||||||
|
|
||||||
Comment rendre un algorithme lisible
|
|
||||||
------------------------------------
|
|
||||||
|
|
||||||
- Le bon algorithme utilise des identifiants explicites.
|
|
||||||
- Le bon algorithme est structuré.
|
|
||||||
- Le bon algorithme est indenté.
|
|
||||||
|
|
||||||
Complexité d'un algorithme
|
|
||||||
--------------------------
|
|
||||||
|
|
||||||
On peut approximer la complexité des algorithmes.
|
|
||||||
C'est utile pour pouvoir comparer des algorithmes.
|
|
||||||
|
|
||||||
complexité
|
|
||||||
|
|
||||||
estimer la complexité d'un algorithme, c'est estimer le nombre de calculs qu'il utilise.
|
|
||||||
|
|
||||||
Si f est la fonction caractérisant exactement le coût d’un algorithme et n
|
|
||||||
la taille des données, on s’intéresse à la façon dont augment f(n) lorsque n augmente
|
|
||||||
on va montrer que f(n) n'augmente pas plus vite qu’une autre fonction
|
|
||||||
g(n). Du point de vue mathématique, on dit que la fonction f est dominée
|
|
||||||
asymptotiquement par la fonction g ce qui se note f = O(g)
|
|
||||||
|
|
||||||
- Complexité temporelle : c’est le nombre d’op«erations effectuées par
|
|
||||||
une machine qui exécute l’algorithme.
|
|
||||||
|
|
||||||
- Complexité spatiale : c’est le nombre de positions mémoire utilisées par
|
|
||||||
une machine qui exécute l’algorithme.
|
|
||||||
|
|
|
||||||
|
|
@ -1,198 +1 @@
|
||||||
Présentation de l'art de programmer
|
.. include:: ../../tronCommun/fondement.txt
|
||||||
====================================
|
|
||||||
|
|
||||||
Qu'est-ce que la programmation ?
|
|
||||||
--------------------------------
|
|
||||||
|
|
||||||
programmation
|
|
||||||
|
|
||||||
Description d’un calcul (traitement) dans
|
|
||||||
un langage compréhensible par la machine
|
|
||||||
(langage de programmation)
|
|
||||||
|
|
||||||
Le processus d'abstraction
|
|
||||||
--------------------------
|
|
||||||
|
|
||||||
Débuter en programmation n'est pas une chose aisée. Aujourd'hui, la tendance est au
|
|
||||||
"bas niveau". Souvent, on se jette dans le grand bain :
|
|
||||||
|
|
||||||
- soit en s'approchant au maximum de la machine (admin système et réseau, noyau
|
|
||||||
linux, langage C)
|
|
||||||
|
|
||||||
- soit en faisant du dev web côté backend, ce qui ramène à une administration réseau
|
|
||||||
de bas niveau (microservices, monde nodeJS/javascript, etc...)
|
|
||||||
|
|
||||||
Soit on suit un cursus scolaire traditionnel qui commence souvent par une
|
|
||||||
explication du fonctionnement d'une machine abstraite de bas niveau, puis en
|
|
||||||
allant de plus en plus haut, mais étant sous-entendu qu'il faut rester connecté au
|
|
||||||
bas niveau (comprendre comment ça se passe derrière la scène).
|
|
||||||
|
|
||||||
Dans ces deux cas, il est sous-entendu qu'on apprend plus de choses et plus rapidement en mettant
|
|
||||||
les mains dans le cambouis, ce qui est vrai bien sûr. Mais cela sous-entend qu'un développeur doit
|
|
||||||
rester le nez dans le guidon. Qu'il doit être un expert de son domaine en accumulant des technologies
|
|
||||||
sans aucun recul. Bien sûr il se doit d'être un expert du système dans lequel il évolue
|
|
||||||
(connaissance du système d'exploitation, binding avec le C, du ramasse miette (garbage
|
|
||||||
collector), interaction avec les différentes librairies, gestion et optimisation de la mémoire,
|
|
||||||
architecture par microservices, threads...) mais il doit aussi être capable de prendre du recul.
|
|
||||||
|
|
||||||
L'approche algorithmique (algorithmique de pseudo code, algorithmique algébrique et modulaire)
|
|
||||||
est un véritable moyen pour le programmeur de prendre du recul : elle commence par se placer du
|
|
||||||
côté de l'esprit humain et de ses capacités de compréhension et d'abstraction, elle autorise une
|
|
||||||
pensée rationnelle sur l'art de programmer et permet au programmeur d'effectuer les bons choix,
|
|
||||||
en connaissance de sa discipline.
|
|
||||||
|
|
||||||
Le lien est fait ensuite avec le plus bas niveau grâce une implémentation effective
|
|
||||||
des langages à partir des paradigmes de rationalisation de la penseée (modules,
|
|
||||||
objects, généricité, polymorphisme paramétrique...) et d'un outil de communication
|
|
||||||
avec la machine qu'on appelle compilateur (dont la description est en dehors de
|
|
||||||
l'objectif de ce cours).
|
|
||||||
|
|
||||||
La tendance générale de l'évolution des langages est de se libérer de ces
|
|
||||||
contraintes de bas niveau, un peu comme en sciences physiques où les lois physiques
|
|
||||||
dépendent de l'échelle d'en dessous (du niveau microscopique/quantique) mais qu'à
|
|
||||||
l'échelle du dessus, on n'a pas affaire à des effets de bas niveau (pas d'effets
|
|
||||||
quantiques à un niveau macroscopique en général). Ce processus d'évolution est vrai
|
|
||||||
aussi dans le monde de la technique informatique lui-même (modèle OSI, comment est
|
|
||||||
construite une trame IP, indépendances de chaque couche (transport, payload) entre
|
|
||||||
elles). Même la tendance système est à la virtualisation qui accentue encore la
|
|
||||||
tendance à s'affranchir du bas niveau (le niveau système), le séparer nettement du
|
|
||||||
haut niveau (le niveau applicatif).
|
|
||||||
|
|
||||||
Il apparaît régulièrement de nouveaux langages. Comment s'orienter ? Quel(s)
|
|
||||||
langage(s) choisir pour un projet de développement ? Au delà de leurs disparités, la
|
|
||||||
conception et la genèse de chacun d'eux procèdent d'une motivation partagée : la
|
|
||||||
volonté d'abstraire.
|
|
||||||
|
|
||||||
- **s'abstraire de la machine** : un langage de programmation permet de
|
|
||||||
négliger l'aspect *mécanique* de l'ordinateur. On oublie le modèle du
|
|
||||||
microprocesseur, jusqu'au système d'exploitation sur lequel sera exécuté
|
|
||||||
le programme.
|
|
||||||
|
|
||||||
- **abstraire les erreurs** : Il s'agit ici de garantir la sûreté d'exécution; un
|
|
||||||
programme ne doit pas se terminer brutalement ou devenir incohérent en cas d'erreur.
|
|
||||||
Un des moyens pour y parvenir est le typage des programmes et la mise
|
|
||||||
en oeuvre d'un mécanisme d'exceptions.
|
|
||||||
|
|
||||||
- **abstraire le mode opératoire** : Il s'agit de choisir une représentation, un
|
|
||||||
paradigme d'implémentation qui est indépendant du domaine considéré (paradigme
|
|
||||||
objet, modulaire, générique, composants...)
|
|
||||||
|
|
||||||
- **abstraire les composants** : Les langages de programmation donnent la
|
|
||||||
possibilité de découper une application en différents composants logiciels, plus ou
|
|
||||||
moins indépendants et autonomes. La modularité permet une structuration de plus haut
|
|
||||||
niveau de l'ensemble d'une application complexe. Les langages à objets constituent
|
|
||||||
une autre approche de la réutilisabilité permettant la réalisation très rapide de
|
|
||||||
prototypes.
|
|
||||||
|
|
||||||
Description des niveaux d'abstraction par rapport à la machine
|
|
||||||
---------------------------------------------------------------
|
|
||||||
|
|
||||||
Les langages de haut niveau simplifient le travail du
|
|
||||||
programmeur là où les langages de bas niveau permettent de produire un code
|
|
||||||
plus efficace.
|
|
||||||
|
|
||||||
- **niveau 0** : le langage machine. Illisible, c'est une suite d'optcode.
|
|
||||||
impossible de coder dans ce langage.
|
|
||||||
|
|
||||||
- **niveau 1** : langage d'assemblage. Il reste très dépendant de la machine
|
|
||||||
et aujourd'hui il est rare d'en faire, sauf si on code un bootloader par exemple,
|
|
||||||
la gestion de l'accès à la mémoire est en réel (le mode protégé n'apparaît que après).
|
|
||||||
Il faut gérer les ressources,le langage est très optimisé mais presque impossible
|
|
||||||
à maintenir et rendre générique. Aujourd'hui plus personne ne code en assembleur.
|
|
||||||
|
|
||||||
- **niveau 2** : langages dits de **bas niveau** : (exemple : le C, le C++)
|
|
||||||
indépendance par rapport à la machine, grande structuration mais très verbeux
|
|
||||||
|
|
||||||
- **niveau 3** : langages dits de **haut niveau** : le raisonnement dans ces
|
|
||||||
langages ne dépent plus de la machine, et ils implémentent des paradigmes de
|
|
||||||
programmation indépendant de l'état de la mémoire de l'ordinateur,
|
|
||||||
ils sont indépendant même du système d'exploitation.
|
|
||||||
|
|
||||||
Qu'est-ce qu'une machine ?
|
|
||||||
---------------------------
|
|
||||||
|
|
||||||
Une machine, ce truc apparemment si complexe, est en fait
|
|
||||||
un assemblage de bric et de brac.
|
|
||||||
|
|
||||||
L'assemblage des connecteurs permet de simuler un additionneur,
|
|
||||||
en prenant en compte les propriétés de **reste euclidien**
|
|
||||||
de l'addition.
|
|
||||||
|
|
||||||
La structure électronique est composée de :
|
|
||||||
|
|
||||||
- un ordonnanceur.
|
|
||||||
- le stockage d'un **état**.
|
|
||||||
- une pile d'instruction
|
|
||||||
|
|
||||||
.. glossary::
|
|
||||||
|
|
||||||
adressage
|
|
||||||
|
|
||||||
Dès lors qu'on dispose de ces bases électronique au dessus du processeur,
|
|
||||||
un langage d'assemblage est possible, c'est le langage de calcul sur les registres.
|
|
||||||
|
|
||||||
registre
|
|
||||||
|
|
||||||
machines ont un espace mémoire et un espace de calcul (registres)
|
|
||||||
|
|
||||||
Un ordinateur, c'est très très stupide, mais ça permet de disposer de :
|
|
||||||
|
|
||||||
- une mémoire très grande et ordonnée,
|
|
||||||
- une capacité à effectuer inlassablement des tâches répétitives
|
|
||||||
- une grande rapidité de calcul
|
|
||||||
|
|
||||||
Apprendre à programmer, c'est-à-dire être capable de
|
|
||||||
contrôler la machine.
|
|
||||||
|
|
||||||
.. important:: Apprendre à programmer, c'est-à-dire apprendre à penser de manière structurée,
|
|
||||||
pour pouvoir accessoirement ensuite communiquer avec une machine.
|
|
||||||
|
|
||||||
Compilateur
|
|
||||||
-----------
|
|
||||||
|
|
||||||
Schématiquement, un compilateur est un programme qui traduit un
|
|
||||||
programme d’un langage source vers un langage cible, en signalant
|
|
||||||
d’éventuelles erreurs.
|
|
||||||
|
|
||||||
Quand on parle de compilation, on pense typiquement à la traduction d’un
|
|
||||||
langage de haut niveau (C, Java, Caml, ...) vers le langage machine d’un
|
|
||||||
processeur (Intel Pentium, PowerPC, ...)
|
|
||||||
|
|
||||||
- xml (libre office, word) -> postscript (imprimante)
|
|
||||||
- postcript -> image
|
|
||||||
- syntaxe wiki -> html (Wikipédia...)
|
|
||||||
|
|
||||||
compilation graphique
|
|
||||||
|
|
||||||
passer une description, ça donne un dessin genre ocaml Quilt < mon_dessin.txt
|
|
||||||
passer par une api qui permet de causer avec une interface
|
|
||||||
|
|
||||||
**transpiler** : transformation d'un langage de haut niveau vers un autre
|
|
||||||
langage de haut niveau.
|
|
||||||
|
|
||||||
- cofee script, typescript -> javascript
|
|
||||||
- (babel) javascript -> javascript ES 6
|
|
||||||
- python -> javascript
|
|
||||||
|
|
||||||
Un compilateur traduit un programme P en un programme Q tel que
|
|
||||||
pour toute entrée x , la sortie de `Q(x)` soit la même que celle de `P(x)`
|
|
||||||
|
|
||||||
Un interprète est un programme qui, étant donné un programme `P` et une
|
|
||||||
entrée x , calcule la sortie s de `P(x)`
|
|
||||||
|
|
||||||
Le compilateur fait un travail complexe une seule fois, pour produire un
|
|
||||||
code fonctionnant pour n’importe quelle entrée
|
|
||||||
L’interprète effectue un travail plus simple, mais le refait sur chaque entrée
|
|
||||||
Autre différence : le code compilé est généralement bien plus efficace que
|
|
||||||
le code interprété
|
|
||||||
|
|
||||||
Typiquement, le travail d’un compilateur se compose d’une phase d’analyse
|
|
||||||
|
|
||||||
- reconnaît le programme à traduire et sa signification
|
|
||||||
- signale les erreurs et peut donc échouer (erreurs de syntaxe, de portée, de typage, etc.)
|
|
||||||
|
|
||||||
Puis d’une phase de synthèse
|
|
||||||
|
|
||||||
- production du langage cible
|
|
||||||
- utilise de nombreux langages intermédiaires
|
|
||||||
- n’échoue pas
|
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
Introduction à l'algorithmique
|
Algorithmique Approfondie
|
||||||
================================
|
=========================
|
||||||
|
|
||||||
.. toctree::
|
.. toctree::
|
||||||
:maxdepth: 2
|
:maxdepth: 2
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1 @@
|
||||||
|
.. include:: ../../tronCommun/langage.txt
|
||||||
|
|
@ -1,291 +0,0 @@
|
||||||
Algorithmique
|
|
||||||
=============
|
|
||||||
|
|
||||||
Al-Kharezmi, auteur du traité "Kitab al jabr w'al-muqabala", est l'inventeur
|
|
||||||
des manipulations algébriques (algèbre = **al jabr**).
|
|
||||||
C'est Léonard de Pise, dit Fibonacci, qui emprunta le nom du célèbre
|
|
||||||
mathématicien arabe du 9ème siècle, mais l'algèbre existe
|
|
||||||
depuis bien plus longtemps (Depuis Babylone, puis ensuite l'Egypte ancienne).
|
|
||||||
|
|
||||||
.. glossary::
|
|
||||||
|
|
||||||
|
|
||||||
algorithme
|
|
||||||
|
|
||||||
terme désignant une suite d'opérations constituant un schéma de calcul
|
|
||||||
ou de résolution d'un problème. C'est un processus systématique de
|
|
||||||
résolution d'un problème permettant de décrire précisément des étapes.
|
|
||||||
C'est une suite finie d'instructions permettant de donner la réponse à un
|
|
||||||
problème.
|
|
||||||
|
|
||||||
L'algorithmique est l'étude et la production de règles et de techniques
|
|
||||||
qui sont impliquées dans la définition d'algorithmes.
|
|
||||||
|
|
||||||
Implémentation d'un algorithme
|
|
||||||
------------------------------
|
|
||||||
|
|
||||||
.. glossary::
|
|
||||||
|
|
||||||
implémentation
|
|
||||||
|
|
||||||
Adaptation de la méthodologie de calculabilité au calcul effectif
|
|
||||||
sur une machine abstraite ou via un langage formel.
|
|
||||||
|
|
||||||
Il n’y a pas de parcours à sens unique de l’algorithme vers l’implantation.
|
|
||||||
La quête d’une implantation efficace nous amène souvent à effectuer
|
|
||||||
un retour vers les algorithmes eux-mêmes, et à en modifier des points
|
|
||||||
essentiels. L’aspect théorique de réflexion sur les algorithmes,
|
|
||||||
et l’aspect pratique de l'implémentation sont donc en symbiose.
|
|
||||||
|
|
||||||
Un existant émerge de la décomposition structurale d'un
|
|
||||||
domaine de base. Le fait essentiel, c'est la genèse des genres de l'existant les
|
|
||||||
uns à partir des autres.
|
|
||||||
|
|
||||||
L'essence d'une forme (un algorithme) se réalise au sein d'une matière qu'elle créée
|
|
||||||
(un langage). L'origine d'une matière fait naître les formes (concepts)
|
|
||||||
que sa structure dessine.
|
|
||||||
|
|
||||||
- Notion structurale de non-contradiction
|
|
||||||
- Notion extensive de "réalisation dans un champ donné"
|
|
||||||
|
|
||||||
Deux aspects réciproques : l'essence d'une forme se réalise au sein d'une
|
|
||||||
matière qu'elle crée, l'essence d'une matière faisant naître les formes que sa
|
|
||||||
structure dessine.
|
|
||||||
|
|
||||||
Abandonner l'idée trop simpliste de domaines concrets et d'opérations abstraites
|
|
||||||
qui posséderaient en eux-mêmes comme une nature de matière et une nature de
|
|
||||||
forme ; cette conception tendrait, en effet, à stabiliser les existants
|
|
||||||
mathématiques dans certains rôles immuables et ignorerait le fait que les
|
|
||||||
existants abstraits qui naissent de la structure d'un domaine plus concret
|
|
||||||
peuvent à leur tour servir de domaine de base pour la genèse d'autres existants.
|
|
||||||
|
|
||||||
L'algorithme comme généralisation de la calculabilité
|
|
||||||
------------------------------------------------------
|
|
||||||
|
|
||||||
L'importance croissante de l'informatique comme outil scientifique
|
|
||||||
impose d'élaborer un nouveau mode de description des méthodes de calcul (appelées algorithmes)
|
|
||||||
susceptible de satisfaire à la fois le critère de sécurité (maîtrise du résultat) et la possibilité
|
|
||||||
d'implémenter les calculs sur un ordinateur.
|
|
||||||
|
|
||||||
Exemple d'algorithme
|
|
||||||
---------------------
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
\begin{algorithm}
|
|
||||||
\caption{L'alorithme de Bellman-Kalaba}
|
|
||||||
\begin{algorithmic}[1]
|
|
||||||
\Procedure {BellmanKalaba}{$G$, $u$, $l$, $p$}
|
|
||||||
\ForAll {$v \in V(G)$}
|
|
||||||
\State $l(v) \leftarrow \infty$
|
|
||||||
\EndFor
|
|
||||||
\State $l(u) \leftarrow 0$
|
|
||||||
\Repeat
|
|
||||||
\For {$i \leftarrow 1, n$}
|
|
||||||
\State $min \leftarrow l(v_i)$
|
|
||||||
\For {$j \leftarrow 1, n$}
|
|
||||||
\If {$min > e(v_i, v_j) + l(v_j)$}
|
|
||||||
\State $min \leftarrow e(v_i, v_j) + l(v_j)$
|
|
||||||
\State $p(i) \leftarrow v_j$
|
|
||||||
\EndIf
|
|
||||||
\EndFor
|
|
||||||
\State $l(i) \leftarrow min$
|
|
||||||
\EndFor
|
|
||||||
\State $changed \leftarrow l \not= l’$
|
|
||||||
\State $l \leftarrow l$
|
|
||||||
\Until{$\neg changed$}
|
|
||||||
\EndProcedure
|
|
||||||
\Statex
|
|
||||||
\Procedure {FindPathBK}{$v$, $u$, $p$}
|
|
||||||
\If {$v = u$}
|
|
||||||
\State \textbf{Write} $v$
|
|
||||||
\Else
|
|
||||||
\State $w \leftarrow v$
|
|
||||||
\While {$w \not= u$}
|
|
||||||
\State \textbf{Write} $w$
|
|
||||||
\State $w \leftarrow p(w)$
|
|
||||||
\EndWhile
|
|
||||||
\EndIf
|
|
||||||
\EndProcedure
|
|
||||||
\end{algorithmic}
|
|
||||||
\end{algorithm}
|
|
||||||
|
|
||||||
Exemple d'algorithme avec son implémentation
|
|
||||||
---------------------------------------------
|
|
||||||
|
|
||||||
Soit l'algorithme de factorielle suivant,
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
\begin{algorithm}
|
|
||||||
\caption{Algorithme de la factorielle d'un nombre}\label{factorielle}
|
|
||||||
\begin{algorithmic}[1]
|
|
||||||
\Function{factorielle}{$n$}\Comment{La fonction récursive factorielle}
|
|
||||||
\BState \emph{parametre} : $n$ entier
|
|
||||||
\If{$n = 1$}
|
|
||||||
\BState \emph{Sortie} : 1
|
|
||||||
\Else
|
|
||||||
\BState \emph{Sortie} : $n * \Call{factorielle}{n-1}$ \Comment{On appelle la fonction dans l'algorithme lui-même}
|
|
||||||
\EndIf
|
|
||||||
\EndFunction
|
|
||||||
\end{algorithmic}
|
|
||||||
\end{algorithm}
|
|
||||||
|
|
||||||
et son implémentation en python :
|
|
||||||
|
|
||||||
.. literalinclude:: code/factorielle.py
|
|
||||||
:language: python
|
|
||||||
|
|
||||||
En voici une autre implémentation (en OCaml) :
|
|
||||||
|
|
||||||
.. literalinclude:: code/factorielle.ml
|
|
||||||
:language: ocaml
|
|
||||||
|
|
||||||
On remarque que le **pseudocode** est très proche de
|
|
||||||
la syntaxe du python :
|
|
||||||
|
|
||||||
.. function:: factorielle(n:int)
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
if n=1
|
|
||||||
return 1
|
|
||||||
else
|
|
||||||
return n * factorielle(n-1)
|
|
||||||
end if
|
|
||||||
|
|
||||||
Qualité d'un algorithme
|
|
||||||
-----------------------
|
|
||||||
|
|
||||||
- correction d'un algorithme
|
|
||||||
- complétude d'un algorithme
|
|
||||||
|
|
||||||
Sémantique
|
|
||||||
|
|
||||||
Étude du sens, de la signification d'un langage
|
|
||||||
Définir la sémantique d’un langage formel consiste à lui donner une
|
|
||||||
signification mathématique.
|
|
||||||
|
|
||||||
Sémantique opérationnelle
|
|
||||||
|
|
||||||
on définit la sémantique par sa mise en œuvre sur
|
|
||||||
une machine abstraite.
|
|
||||||
|
|
||||||
Sémantique dénotationnelle
|
|
||||||
|
|
||||||
on associe à chaque construction syntaxique un
|
|
||||||
objet mathématique
|
|
||||||
|
|
||||||
Sémantique axiomatique
|
|
||||||
|
|
||||||
chaque construction est décrite par la manière dont
|
|
||||||
elle transforme des propriétés ou des prédicats.
|
|
||||||
|
|
||||||
Proposition
|
|
||||||
|
|
||||||
une proposition est un énoncé qui est soit vrai, soit faux
|
|
||||||
|
|
||||||
**exemple** : ``2 + 3 = 5``. Proposition vraie.
|
|
||||||
|
|
||||||
Prédicats
|
|
||||||
|
|
||||||
Une proposition dont la valeur de vérité dépend de la valeur d’une ou plusieurs variables
|
|
||||||
|
|
||||||
**Exemple** : ``n est pair`` : vrai pour n = 4 mais faux pour n = 9
|
|
||||||
|
|
||||||
|
|
||||||
Axiome
|
|
||||||
|
|
||||||
une proposition qui est supposée vraie
|
|
||||||
|
|
||||||
Un ensemble d’axiomes est consistant s’il n’existe pas de proposition
|
|
||||||
dont on peut démontrer qu’elle est à la fois vraie et fausse.
|
|
||||||
|
|
||||||
Un ensemble d’axiomes est complet si, pour toute proposition, il est
|
|
||||||
possible de démontrer qu’elle est vraie ou fausse.
|
|
||||||
|
|
||||||
Théorème d’incomplétude de Gödel (1931) : tout ensemble
|
|
||||||
consistant d’axiomes pour l’arithmétique sur les entiers est
|
|
||||||
nécessairement incomplet.
|
|
||||||
|
|
||||||
**Les concepts de base en algorithmique sont les axiomes**
|
|
||||||
|
|
||||||
inférence
|
|
||||||
|
|
||||||
règles d’inférence, règles permettant de combiner des axiomes et des
|
|
||||||
propositions vraies pour établir de nouvelles propositions vraies.
|
|
||||||
|
|
||||||
Démonstration
|
|
||||||
|
|
||||||
vérification d’une proposition par une séquence de déductions logiques
|
|
||||||
à partir d’un ensemble d’axiomes.
|
|
||||||
|
|
||||||
Lorsque le champ donné (le domaine) ne contient qu'un nombre fini d'individus,
|
|
||||||
on peut définir un choix de valeur des variables permettant de vérifier la
|
|
||||||
proposition obtenue par la *conjonction* de tous les axiomes du système proposé.
|
|
||||||
On dit alors que ce choix *réalise* un système d'axiomes.
|
|
||||||
|
|
||||||
|
|
||||||
Il ne s'agit plus de savoir si la définition entraîne l'existence, mais de
|
|
||||||
chercher si la structure d'un système d'axiomes (*règles*) peut donner naissance
|
|
||||||
à un champ d'individus qui soutiennent entre eux les relations définies pas les
|
|
||||||
axiomes.
|
|
||||||
|
|
||||||
Concret et abstrait
|
|
||||||
--------------------
|
|
||||||
|
|
||||||
Il est possible qu'un même genre d'existant joue dans un schéma de genèse le
|
|
||||||
rôle d'abstrait par rapport à un concret de base, et soit au contraire dans une
|
|
||||||
autre genèse le concret de base d'un nouvel abstrait.
|
|
||||||
|
|
||||||
Une pareille présentation des choses implique un tel renversement par rapport
|
|
||||||
aux habitudes de pensée classiques, qu'il faut encore insister sur le sens
|
|
||||||
nouveau que reçoivent ici les expressions de "concret" et "d'abstrait".
|
|
||||||
|
|
||||||
Les systèmes d'axiomes sont souvent conçus comme des structures purement
|
|
||||||
formelles, abstraites. Ces structures sont si profondément engagées dans la
|
|
||||||
genèse de leurs réalisations, qu'il valait mieux désigner par ces termes les
|
|
||||||
structures de base.
|
|
||||||
|
|
||||||
Un système d'axiome *peut* devenir le concret de base.
|
|
||||||
|
|
||||||
Ceci permet d'exprimer non seulement l'engagement du concret dans la genèse de
|
|
||||||
l'abstrait, mais encore les relations d'imitation qui peuvent exister entre la
|
|
||||||
structure de cet abstrait et celle du concret de base.
|
|
||||||
|
|
||||||
Dans certains cas, la genèse de l'abstrait à partir d'un concret de base
|
|
||||||
s'affirme jusqu'à réaliser une imitation de structure entre ces genres
|
|
||||||
d'existants qui naissent l'un de l'autre.
|
|
||||||
|
|
||||||
**C'est pourquoi on représente souvent un algorithme en pseudo-code**,
|
|
||||||
c'est-à-dire en fait dans le mode de représentation (issu du langage préféré de la
|
|
||||||
personne qui l'exprime) dominant chez la personne qui exprime un algorithme.
|
|
||||||
|
|
||||||
Comment rendre un algorithme lisible
|
|
||||||
------------------------------------
|
|
||||||
|
|
||||||
- Le bon algorithme utilise des identifiants explicites.
|
|
||||||
- Le bon algorithme est structuré.
|
|
||||||
- Le bon algorithme est indenté.
|
|
||||||
|
|
||||||
Complexité d'un algorithme
|
|
||||||
--------------------------
|
|
||||||
|
|
||||||
On peut approximer la complexité des algorithmes.
|
|
||||||
C'est utile pour pouvoir comparer des algorithmes.
|
|
||||||
|
|
||||||
complexité
|
|
||||||
|
|
||||||
estimer la complexité d'un algorithme, c'est estimer le nombre de calculs qu'il utilise.
|
|
||||||
|
|
||||||
Si f est la fonction caractérisant exactement le coût d’un algorithme et n
|
|
||||||
la taille des données, on s’intéresse à la façon dont augment f(n) lorsque n augmente
|
|
||||||
on va montrer que f(n) n'augmente pas plus vite qu’une autre fonction
|
|
||||||
g(n). Du point de vue mathématique, on dit que la fonction f est dominée
|
|
||||||
asymptotiquement par la fonction g ce qui se note f = O(g)
|
|
||||||
|
|
||||||
- Complexité temporelle : c’est le nombre d’op«erations effectuées par
|
|
||||||
une machine qui exécute l’algorithme.
|
|
||||||
|
|
||||||
- Complexité spatiale : c’est le nombre de positions mémoire utilisées par
|
|
||||||
une machine qui exécute l’algorithme.
|
|
||||||
|
|
@ -1,294 +0,0 @@
|
||||||
Les structures de contrôle
|
|
||||||
==========================
|
|
||||||
|
|
||||||
L'instruction de saut
|
|
||||||
----------------------
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
\begin{algorithm}
|
|
||||||
\caption{Exemple de saut conditionnel}\label{saut}
|
|
||||||
\begin{algorithmic}[1]
|
|
||||||
\Procedure{Euclide}{} \Comment{c'est l'algorithme d'Euclide}
|
|
||||||
\State $\textit{stringlen} \gets \text{length of }\textit{string}$
|
|
||||||
\State $i \gets \textit{patlen}$
|
|
||||||
\BState \emph{top}:
|
|
||||||
\If {$i > \textit{stringlen}$} \Return false
|
|
||||||
\EndIf
|
|
||||||
\State $j \gets \textit{patlen}$
|
|
||||||
\BState \emph{loop}: \Comment{C'est le label (l'étiquette)} \label{etiquette}
|
|
||||||
\If {$\textit{string}(i) = \textit{path}(j)$}
|
|
||||||
\State $j \gets j-1$.
|
|
||||||
\State $i \gets i-1$.
|
|
||||||
\State \textbf{goto} \emph{loop}. \label{goto}
|
|
||||||
\State \textbf{close};
|
|
||||||
\EndIf
|
|
||||||
\State $i \gets
|
|
||||||
i+\max(\textit{delta}_1(\textit{string}(i)),\textit{delta}_2(j))$.
|
|
||||||
\State \textbf{goto} \emph{top}. \Comment{C'est l'instruction de saut}
|
|
||||||
\EndProcedure
|
|
||||||
\end{algorithmic}
|
|
||||||
\end{algorithm}
|
|
||||||
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
Ligne \ref{etiquette}, le bloc `loop` est aussi un label (une étiquette),
|
|
||||||
c'est-à-dire une marque posée qu'il est possible de retrouver dans le programme. \\
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
Ligne \ref{goto}, l'instruction \texttt{goto} (aller à ) est le saut vers le label. \\
|
|
||||||
|
|
||||||
Description générique d'une instruction de saut::
|
|
||||||
|
|
||||||
Instruction 1
|
|
||||||
Saut Label1
|
|
||||||
Instruction 2
|
|
||||||
...
|
|
||||||
Label1:
|
|
||||||
Instruction n
|
|
||||||
|
|
||||||
.. important:: les sauts conditionnels sont à éviter, même s'ils sont implémentés
|
|
||||||
dans le langage cible, car c'est le meilleur moyen d'aboutir à
|
|
||||||
du **code spaghetti**.
|
|
||||||
|
|
||||||
L'instruction de branchement conditionnel
|
|
||||||
------------------------------------------
|
|
||||||
|
|
||||||
On appelle structure conditionnelle les instructions qui permettent de tester si une condition est vraie ou non.
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
\begin{algorithm}
|
|
||||||
\caption{Exemple d'instruction de test}
|
|
||||||
\begin{algorithmic}[1]
|
|
||||||
\BState \emph{entrée}: $quality\gets 0$ \Comment{C'est cette valeur qui sera testée}
|
|
||||||
\BState \emph{locale}: $a\gets ""$
|
|
||||||
\BState \emph{sortie}: $a$ \Comment{La sortie est la valeur de $a$}
|
|
||||||
\BState \emph{corps}:
|
|
||||||
\If{$quality\ge 9$}
|
|
||||||
\State $a\gets perfect$
|
|
||||||
\ElsIf{$quality\ge 7$}
|
|
||||||
\State $a\gets good$
|
|
||||||
\ElsIf{$quality\ge 5$}
|
|
||||||
\State $a\gets medium$
|
|
||||||
\ElsIf{$quality\ge 3$}
|
|
||||||
\State $a\gets bad$
|
|
||||||
\Else
|
|
||||||
\State $a\gets unusable$
|
|
||||||
\EndIf
|
|
||||||
\end{algorithmic}
|
|
||||||
\end{algorithm}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
.. ifconfig:: exercice
|
|
||||||
|
|
||||||
**Exercice** : Compacter l'algorithme suivant en une seule condition de test::
|
|
||||||
|
|
||||||
Si il fait trop chaud Alors
|
|
||||||
Si il ne pleut pas Alors
|
|
||||||
Ouvrir la fenêtre
|
|
||||||
Sinon
|
|
||||||
Fermer la fenêtre
|
|
||||||
Finsi
|
|
||||||
Sinon
|
|
||||||
Fermer la fenêtre
|
|
||||||
Finsi
|
|
||||||
|
|
||||||
.. ifconfig:: correction
|
|
||||||
|
|
||||||
**Correction** :
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
Si il fait trop chaud ET il ne pleut pas Alors
|
|
||||||
Ouvrir la fenêtre
|
|
||||||
Sinon
|
|
||||||
Fermer la fenêtre
|
|
||||||
Finsi
|
|
||||||
|
|
||||||
|
|
||||||
L'instruction switch
|
|
||||||
--------------------
|
|
||||||
|
|
||||||
L'instruction switch permet de faire plusieurs tests de valeurs sur le contenu d'une même variable.
|
|
||||||
Ce branchement conditionnel simplifie beaucoup le test de plusieurs valeurs d'une variable.
|
|
||||||
|
|
||||||
Les instructions d'itérations (boucles)
|
|
||||||
---------------------------------------
|
|
||||||
|
|
||||||
.. important:: Toutes les boucles concernent le paradigme de programmation impératif
|
|
||||||
et ne sont pas valides dans le paradigme de programmation fonctionnel
|
|
||||||
(puisque l'ordre d'évaluation importe)
|
|
||||||
|
|
||||||
- arrêt conditionnel (break)
|
|
||||||
- passage d'un pas (continue)
|
|
||||||
|
|
||||||
Répéter ... jusqu'à
|
|
||||||
~~~~~~~~~~~~~~~~~~~
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
\begin{algorithm}
|
|
||||||
\caption{Exemple de répéter ... jusqu'à}
|
|
||||||
\begin{algorithmic}[1]
|
|
||||||
\BState \emph{locales}: $i \gets 1$ \Comment{déclaration et initialisation de i}
|
|
||||||
\Repeat \Comment{c'est le label de début du répéter}
|
|
||||||
\State $i \gets \textit{i+1}$
|
|
||||||
\Until{i == 100} \Comment{condition de fin de la boucle}
|
|
||||||
\end{algorithmic}
|
|
||||||
\end{algorithm}
|
|
||||||
|
|
||||||
La boucle **pour** (for)
|
|
||||||
~~~~~~~~~~~~~~~~~~~~~~~~
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
\begin{algorithm}
|
|
||||||
\caption{Exemple de boucle for}
|
|
||||||
\begin{algorithmic}[1]
|
|
||||||
\BState \emph{locales}: $sum\gets 0$
|
|
||||||
\For{$i\gets 1, n$}
|
|
||||||
\State $sum\gets sum+i$
|
|
||||||
\EndFor
|
|
||||||
\end{algorithmic}
|
|
||||||
\end{algorithm}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
.. ifconfig:: exercice
|
|
||||||
|
|
||||||
**Exercice** : Ecrire un algorithme qui demande successivement 20 nombres à l’utilisateur,
|
|
||||||
et qui lui dise ensuite quel était le plus grand parmi ces 20 nombres
|
|
||||||
|
|
||||||
.. ifconfig:: correction
|
|
||||||
|
|
||||||
**Correction** :
|
|
||||||
::
|
|
||||||
|
|
||||||
Variables N, i, PG en Entier
|
|
||||||
Debut
|
|
||||||
PG <- 0
|
|
||||||
Pour i <- 1 à 20
|
|
||||||
Ecrire "Entrez un nombre : "
|
|
||||||
Lire N
|
|
||||||
Si i = 1 ou N > PG Alors
|
|
||||||
PG <- N
|
|
||||||
FinSi
|
|
||||||
Ecrire "Le nombre le plus grand était : ", PG
|
|
||||||
Fin
|
|
||||||
|
|
||||||
|
|
||||||
.. attention:: ne jamais manipuler le compteur dans une boucle
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
Variable Truc en Entier
|
|
||||||
Début
|
|
||||||
Pour Truc <- 1 à 15
|
|
||||||
Truc <- Truc * 2
|
|
||||||
Ecrire "Passage numéro : ", Truc
|
|
||||||
Truc Suivant
|
|
||||||
Fin
|
|
||||||
|
|
||||||
La boucle tant que (while)
|
|
||||||
~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
\begin{algorithm}
|
|
||||||
\caption{Exemple de boucle while}
|
|
||||||
\begin{algorithmic}[1]
|
|
||||||
\BState \emph{locales}: $sum\gets 0$
|
|
||||||
\State $i\gets 1$
|
|
||||||
\While{$i\le n$}
|
|
||||||
\State $sum\gets sum+i$
|
|
||||||
\State $i\gets i+1$
|
|
||||||
\EndWhile
|
|
||||||
\end{algorithmic}
|
|
||||||
\end{algorithm}
|
|
||||||
|
|
||||||
.. ifconfig:: exercice
|
|
||||||
|
|
||||||
**Exercice** : Ecrire un algorithme de validation d'une entrée utilisateur
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
"Voulez vous un café ? (O/N)"
|
|
||||||
|
|
||||||
.. ifconfig:: correction
|
|
||||||
|
|
||||||
**Correction** : deux solutions possibles, une
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
Variable Rep en Caractère
|
|
||||||
Début
|
|
||||||
Rep <- ""
|
|
||||||
Ecrire "Voulez vous un café ? (O/N)"
|
|
||||||
TantQue Rep <> "O" et Rep <> "N"
|
|
||||||
Lire Rep
|
|
||||||
Si Rep <> "O" et Rep <> "N" Alors
|
|
||||||
Ecrire "Saisie Erronée, Recommencez"
|
|
||||||
FinSi
|
|
||||||
FinTantQue
|
|
||||||
Fin
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
Variable Rep en Caractère
|
|
||||||
Début
|
|
||||||
Ecrire "Voulez vous un café ? (O/N)"
|
|
||||||
Lire Rep
|
|
||||||
TantQue Rep <> "O" et Rep <> "N"
|
|
||||||
Ecrire "Vous devez répondre par O ou N. Recommencez"
|
|
||||||
Lire Rep
|
|
||||||
FinTantQue
|
|
||||||
Ecrire "Saisie acceptée"
|
|
||||||
Fin
|
|
||||||
|
|
||||||
.. ifconfig:: exercice
|
|
||||||
|
|
||||||
**Exercice** : "C'est plus, C'est moins", c'est-à-dire Ecrire un algorithme qui demande à l’utilisateur
|
|
||||||
un nombre compris entre a et b jusqu’à ce que la réponse convienne.
|
|
||||||
|
|
||||||
.. ifconfig:: correction
|
|
||||||
|
|
||||||
**Correction** :
|
|
||||||
|
|
||||||
::
|
|
||||||
|
|
||||||
Variable N en Entier
|
|
||||||
Debut
|
|
||||||
N <- 0
|
|
||||||
Ecrire "Entrez un nombre entre 10 et 20"
|
|
||||||
TantQue N < 10 ou N > 20
|
|
||||||
Lire N
|
|
||||||
Si N < 10 Alors
|
|
||||||
Ecrire "Plus grand !"
|
|
||||||
SinonSi N > 20 Alors
|
|
||||||
Ecrire "Plus petit !"
|
|
||||||
FinSi
|
|
||||||
FinTantQue
|
|
||||||
Fin
|
|
||||||
|
|
||||||
Et les autres boucles : répéter... jusqu'à, etc...
|
|
||||||
|
|
||||||
.. raw:: latex
|
|
||||||
|
|
||||||
\begin{algorithm}
|
|
||||||
\caption{Exemple de boucle répéter}
|
|
||||||
|
|
||||||
\begin{algorithmic}[1]
|
|
||||||
\State $sum\gets 0$
|
|
||||||
\State $i\gets 1$
|
|
||||||
\Repeat
|
|
||||||
\State $sum\gets sum+i$
|
|
||||||
\State $i\gets i+1$
|
|
||||||
\Until{$i>n$}
|
|
||||||
\end{algorithmic}
|
|
||||||
\end{algorithm}
|
|
||||||
|
|
@ -7,10 +7,8 @@ Introduction à l'algorithmique
|
||||||
presentation
|
presentation
|
||||||
fondement
|
fondement
|
||||||
langage
|
langage
|
||||||
algo
|
|
||||||
programme
|
programme
|
||||||
fonctions
|
fonctions
|
||||||
control
|
|
||||||
donnees
|
donnees
|
||||||
apercu
|
apercu
|
||||||
modularite
|
modularite
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue