Cadoles/formations
21
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

mise en place des cours algo + poo

Browse Source
This commit is contained in:
gwen
2017-08-28 17:36:36 +02:00
parent 2843f25795
commit dc02e78fff
114 changed files with 26589 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

216
algo/algorithmique/cours/Makefile Normal file
View File

@ -0,0 +1,216 @@
# Makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
PAPER =
BUILDDIR = _build
# User-friendly check for sphinx-build
ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/)
endif
# Internal variables.
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
# the i18n builder cannot share the environment and doctrees with the others
I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
.PHONY: help
help:
@echo "Please use \`make <target>' where <target> is one of"
@echo " html to make standalone HTML files"
@echo " dirhtml to make HTML files named index.html in directories"
@echo " singlehtml to make a single large HTML file"
@echo " pickle to make pickle files"
@echo " json to make JSON files"
@echo " htmlhelp to make HTML files and a HTML help project"
@echo " qthelp to make HTML files and a qthelp project"
@echo " applehelp to make an Apple Help Book"
@echo " devhelp to make HTML files and a Devhelp project"
@echo " epub to make an epub"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@echo " latexpdf to make LaTeX files and run them through pdflatex"
@echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
@echo " text to make text files"
@echo " man to make manual pages"
@echo " texinfo to make Texinfo files"
@echo " info to make Texinfo files and run them through makeinfo"
@echo " gettext to make PO message catalogs"
@echo " changes to make an overview of all changed/added/deprecated items"
@echo " xml to make Docutils-native XML files"
@echo " pseudoxml to make pseudoxml-XML files for display purposes"
@echo " linkcheck to check all external links for integrity"
@echo " doctest to run all doctests embedded in the documentation (if enabled)"
@echo " coverage to run coverage check of the documentation (if enabled)"
.PHONY: clean
clean:
rm -rf $(BUILDDIR)/*
.PHONY: html
html:
$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
.PHONY: dirhtml
dirhtml:
$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
.PHONY: singlehtml
singlehtml:
$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
@echo
@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
.PHONY: pickle
pickle:
$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
@echo
@echo "Build finished; now you can process the pickle files."
.PHONY: json
json:
$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
@echo
@echo "Build finished; now you can process the JSON files."
.PHONY: htmlhelp
htmlhelp:
$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
@echo
@echo "Build finished; now you can run HTML Help Workshop with the" \
".hhp project file in $(BUILDDIR)/htmlhelp."
.PHONY: qthelp
qthelp:
$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
@echo
@echo "Build finished; now you can run "qcollectiongenerator" with the" \
".qhcp project file in $(BUILDDIR)/qthelp, like this:"
@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/Algorithmique.qhcp"
@echo "To view the help file:"
@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/Algorithmique.qhc"
.PHONY: applehelp
applehelp:
$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
@echo
@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
@echo "N.B. You won't be able to view it unless you put it in" \
"~/Library/Documentation/Help or install it in your application" \
"bundle."
.PHONY: devhelp
devhelp:
$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
@echo
@echo "Build finished."
@echo "To view the help file:"
@echo "# mkdir -p $$HOME/.local/share/devhelp/Algorithmique"
@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/Algorithmique"
@echo "# devhelp"
.PHONY: epub
epub:
$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
@echo
@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
.PHONY: latex
latex:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo
@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
@echo "Run \`make' in that directory to run these through (pdf)latex" \
"(use \`make latexpdf' here to do that automatically)."
.PHONY: latexpdf
latexpdf:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through pdflatex..."
$(MAKE) -C $(BUILDDIR)/latex all-pdf
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
.PHONY: latexpdfja
latexpdfja:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through platex and dvipdfmx..."
$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
.PHONY: text
text:
$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
@echo
@echo "Build finished. The text files are in $(BUILDDIR)/text."
.PHONY: man
man:
$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
@echo
@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
.PHONY: texinfo
texinfo:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo
@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
@echo "Run \`make' in that directory to run these through makeinfo" \
"(use \`make info' here to do that automatically)."
.PHONY: info
info:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo "Running Texinfo files through makeinfo..."
make -C $(BUILDDIR)/texinfo info
@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
.PHONY: gettext
gettext:
$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
@echo
@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
.PHONY: changes
changes:
$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
@echo
@echo "The overview file is in $(BUILDDIR)/changes."
.PHONY: linkcheck
linkcheck:
$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
@echo
@echo "Link check complete; look for any errors in the above output " \
"or in $(BUILDDIR)/linkcheck/output.txt."
.PHONY: doctest
doctest:
$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
@echo "Testing of doctests in the sources finished, look at the " \
"results in $(BUILDDIR)/doctest/output.txt."
.PHONY: coverage
coverage:
$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
@echo "Testing of coverage in the sources finished, look at the " \
"results in $(BUILDDIR)/coverage/python.txt."
.PHONY: xml
xml:
$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
@echo
@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
.PHONY: pseudoxml
pseudoxml:
$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
@echo
@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."

BIN
algo/algorithmique/cours/_static/cesi.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 59 KiB

1
algo/algorithmique/cours/algo.txt Normal file
View File

@ -0,0 +1 @@
.. include:: ../../tronCommun/algo.txt

83
algo/algorithmique/cours/annexes/agile.txt Normal file
View File

@ -0,0 +1,83 @@
La planification agile
========================
Le mode itératif
-----------------
- livrer des versions successives et utilisables qui convergent vers
la version finale
- ne pas perdre d'énergie à maintenir des specs détaillées non nécessaires
- de nouvelles orientations fonctionnelles sont possibles, même tard
- les specs détaillées sont écrites "juste à temps"
La planification agile
-----------------------
- chaque livraison est un projet qui est planifié en tant que tel
- utiliser l'expérience acquise pour affiner les estimations
- préservation de l'écologie du projet au quotidien (code, tests...)
La confiance, feedback
-----------------------
- livraisons régulières
- progrès visibles par tous (pas d'effet tunnel)
- pilotage du projet par choix du contenu des livraisons
- investissement du Product Owner
- chercher la collaboration plutôt que la confrontation
L'agilité
----------
- le projet n'est pas joué d'avance
- cultiver la souplesse
- révolution douce
- sortir de la confrontation, jouer le "nous collectif"
mettre tout le monde sur le mme pont et amener tout le monde à bon port
Les outils agiles
------------------
- planification par itérations de 4 semaines
- entrepot de source partagé
- intégration continue
- tests automatisés
- pair programming sur points cruciaux
- sprints
- extranet :
- hitoires utilisateurs
- test cases
- gestion du backolog et des tickets
- suivi de l'avancement
- documentation
Le product owner
-----------------
idéalement,
- connaissance du métier à informatiser
- fibre projet
- dispo à 100%
Les tests
---------
- automatiser
- viser l'exhaustivité
- tester une cible mouvante
- migrer les tests d'une release à l'autre
Questions importantes en environnement agile
----------------------------------------------
- quelle durée d'itération ?
- comment découper en itérations ?
- que faire lorsque le product owner se retrouve sur le chemin critique ?
- la planification est faite en mode "juste à temps" et "juste assez"
- on ne s'échine plus à blâmer, au contraire on cherche à gagner ensemble

19
algo/algorithmique/cours/annexes/exercices.txt Normal file
View File

@ -0,0 +1,19 @@
Exercices complémentaires
--------------------------
+ **Manipulation de chaînes de caractères**:
(création, accès à un caractère, concaténation), listes (création, ajout
d’un élément, suppression d’un élément, accès à un élément, extraction d’une partie de liste), tableaux à une ou plusieurs dimensions.
+ traitement des chaines de caractères
+ s.replace()
+ s1 + s2
+ un exemple de regexp simple
+ **Fichiers** :
notion de chemin d’accès, lecture et écriture de données numériques ou de type chaîne de caractères depuis ou vers un fichier.
On encourage l’utilisation de fichiers en tant que supports de données ou de résultats avant divers traitements, par exemple graphiques.
+ **Piles**
Algorithmes de manipulation : fonctions 'push' et 'pop'. On utilise des listes
(ou tableaux à 1 dimension) pour leur implantation.

10
algo/algorithmique/cours/annexes/index.txt Normal file
View File

@ -0,0 +1,10 @@
Annexes
=========
.. toctree::
:maxdepth: 2
exercices
surete
agile
scrum

176
algo/algorithmique/cours/annexes/scrum.txt Normal file
View File

@ -0,0 +1,176 @@
scrum
=====
.. glossary::
scrum
Scrum est une méthode agile pour la gestion de projets
Le terme Scrum est emprunté au rugby et signifie mêlée.
Ce processus s'articule en effet autour d'une équipe soudée,
qui cherche à atteindre un but, comme c'est le cas en rugby
pour avancer avec le ballon pendant une mêlée.
Scrum définit trois rôles principaux :
- le responsable de produit -- Product Manager,
- le faciliteur -- ScrumMaster
- le développeur
et bien sûr, l'équipe (auto-gérée).
Des intervenants peuvent s'intégrer également au projet
de façon plus ponctuelle.
responsable de produit
Le responsable de produit (Product Manager) est le représentant des
clients et utilisateurs.
C'est lui qui définit l'ordre dans lequel les fonctionnalités
seront développées et qui prend les décisions importantes
concernant l'orientation du projet.
Le terme responsable n'est d'ailleurs pas à prendre au sens hiérarchique
du terme, mais dans le sens de l'orientation.
équipe, développement
outes les décisions sont prises ensemble et personne ne donne d'ordre
à l'équipe sur sa façon de procéder
facilitateur
est chargé de protéger l'équipe de tous les éléments perturbateurs
planification
--------------
Scrum utilise une planification à trois niveaux :
- release/projet
- sprint
- quotidien -- ScrumMeeting
quotidien
Au quotidien, une réunion, le ScrumMeeting (pas plus de 15 min)
permet à l'équipe et au ScrumMaster de faire un point d'avancement sur
les tâches et sur les difficultés rencontrées.
répondre à trois questions :
* Qu'est-ce que j'ai fait hier ?
* Qu'est-ce que je compte faire aujourd'hui ?
* Quelles difficultés est-ce que je rencontre ?
sprint
Scrum est un processus itératif : les itérations sont appelées des sprints
et durent en théorie 30 jours calendaires.
En pratique, les itérations durent généralement entre 2 et 4 semaines.
Chaque sprint possède un but et on lui associe une liste d'items
de fonctionnalités à réaliser.
Ces items sont décomposés par l'équipe en tâches élémentaires
de quelques heures, les items de fonctionnalités de sprint.
Pendant un sprint, les items de fonctionnalités de sprint à réaliser
ne peuvent pas être changés.
Les changements éventuels seront éventuellement réalisés
dans les sprints suivants.
releases
pour améliorer la lisibilité du projet,
on regroupe généralement des itérations en releases.
En effet, comme chaque sprint doit aboutir à la livraison
d'un produit partiel, une release permet de marquer la livraison
d'une version aboutie, susceptible d'être mise en exploitation
gestion des besoins
-------------------
tâches (backlog de sprint)
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Lorsqu'on démarre un sprint, on choisit quels items des fonctionnalités
seront réalisés dans ce sprint.
L'équipe décompose ensuite chaque item en liste de tâches élémentaires
(techniques ou non), chaque tâche étant estimée en heures
et ne devant pas durer plus de 2 jours.
On constitue ainsi le backlog de sprint.
Les items de backlog de produit sont les fonctionnalités qui deviendront
les items du baclog d'un sprint.
Ces fonctionnalités sont estimées en points relatifs, sans unité.
planning poker
façon ludique et efficace de produire des estimations
sur la complexité des fonctionnalités à développer
pour évaluer les scénarios utilisateurs (user stories)
du carnet de produit (product backlog).
à la fin d'un sprint :
- revue de sprint
- rétrospective de sprint
comprendre ce qui n'a pas bien marché dans le sprint,
les erreurs commises et de prendre des décisions pour s'améliorer
mise en oeuvre
--------------
Scrum peut être mis en pratique avec trois fois rien : deux listes suffisent.
La liste des items du backlog de produit et la liste des items du backlog
de sprint. La saisie et la mise à jour des données est simplement
un peu moins agréable.
glossaire
---------
Directeur de produit (Product Owner) (responsable produit)
personne responsable de produire et maintenir à jour le backlog de produit.
C'est lui qui en détermine les priorités et qui prend les décisions
concernant l'orientation du projet.
ScrumMaster (facilitateur)
membre de l'équipe dont l'objectif principal est de la protéger
des perturbation extérieures.
Il est complètement transparent pour la communication entre l'équipe
et les clients et n'a aucun pouvoir hiérarchique sur l'équipe.
C'est en revanche un facilitateur pour les problèmes non techniques
de l'équipe.
Backlog de produit (Product Backlog) (fonctionnalités)
liste des fonctionnalités qui devront être réalisées par le logiciel.
Backlog de sprint (Sprint Backlog) (tâches)
liste des tâches à accomplir pendant un sprint.
Elles correspondent à la réalisation des items de backlog
du produit affectés au sprint.
Mêlée quotidienne (Daily Scrum) (quotidien)
réunion quotidienne de 15 minutes qui a pour but de faire le point
sur ce qui a été fait depuis la dernière mêlée,
ce qui est prévu de faire jusqu'à la prochaine
et quelles sont les embûches rencontrées durant le travail.
Sprint (sprint)
nom d'une itération dans Scrum.
Cette itération dure 30 jours calendaires en théorie,
mais en pratique on utilise plutôt entre 2 et 4 semaines.
Pendant une itération, l'équipe doit développer une liste d'items
du backlog de produit qui a été définie au début de ce sprint.
Graphique d'avancement (Burndown Chart) (avancement)
graphique qui montre la tendance du reste à faire total de jour en jour
(pour les sprints) ou de sprint en sprint (pour les releases).

93
algo/algorithmique/cours/annexes/surete.txt Normal file
View File

@ -0,0 +1,93 @@
Outils de sureté d'un programme
--------------------------------------
La preuve de programme
~~~~~~~~~~~~~~~~~~~~~~
Le niveau maximum de sûreté d'exécution d'un programme est la preuve. Qu'est-ce que la preuve
formelle d'un programme ? Selon la définition de Wikipédia, ce sont "des techniques permettant de
raisonner rigoureusement, à l'aide de logique mathématique, sur des programmes informatiques ou
du matériel électroniques, afin de démontrer leur validité par rapport à une certaine
spécification." Bref c'est un raisonnement logique sur un programmme qui permet d'être sûr que le
programme est valide et ne va pas planter.
La preuve de programme est très peu utilisée dans l'industrie, car très coûteuse et très
difficile à mettre en place. Elle quand même utilisée, mais dans des secteurs où le risque doit
absolument être évacué et où il n'y a aucun droit à l'erreur. Par exemple, le secteur médical
(informatique en bloc opératoire), militaire (peu d'informations nous parviennent dans ce
domaine), l'aviation civile (le logiciel Astrée pour Airbus), la fusée Ariane (depuis le bug qui
avait fait crasher Ariane 5 ces questions sont prises très au sérieux), et le milieu bancaire
(surtout le domaine des décisions boursières : un programme chargé de lancer des décisions
d'achat ou de vente à la bourse qui comporte un bug peut en quelque centièmes de secondes faire
perdre des millions, voire des milliards d'euros à une banque. Le programme ne doit tout simplement pas
bugger).
Le model checking
~~~~~~~~~~~~~~~~~~
Le model checking, l'analyse statique et l'interprétation abstraite procèdent d'une méthodologie
moins lourde de validation des programmes. Ces méthodes analysent exhaustivement l'évolution du
système lors de ses exécutions possibles et permetent de dire si globalement, dans un contexte
donné, le programme va fonctionner correctement. Encore très lourdes, ces techniques ne sont
utilisées que dans un contexte industriel de haute sécurité.
Les tests d'acceptation
~~~~~~~~~~~~~~~~~~~~~~~
Il y a plusieurs types de tests
- unitaires
- fonctionnels
- acceptation
Très utilisés dans l'industrie, les tests unitaires et fonctionnels ne testent que certaines
parties du programme et permettent de dire que le programme va marcher grosso-modo à peu près.
Beaucoup moins coûteux à installer, ce sont des éléments cléfs des méthodes agiles.
Les Outils de linting (validation)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- vérifications syntaxiques
- vérification sémantiques
- vérification sur les imports inutiles ou mal formés (imports croisés
Exemple en python : pylint
La dette technique
~~~~~~~~~~~~~~~~~~
Au bout d'un moment le code devient du code spaghetti et les techniques sont obsolètes.
Les tests permettent de solder la dette technique plus facilement.
**avoir le courage de payer une dette technique, et affronter une dette technique
sinon il peut y avoir un coût à payer qui sera pohibitoire.**
On solde la dette technique parce que à un moment ça va devenir beaucoup trop
cher à payer.
Les méthodologies agiles
~~~~~~~~~~~~~~~~~~~~~~~~
La manière dont le code est produit importe énormément. Par exemple, une
méthodologie ou le **refactoring** (réécriture de code) est permis et même conseillé
a plus de chance de produire du code organisé.
Les méthodologies agiles produisent en général du code mieux organisé. Ce sont les
méthodes de travail les plus en vogue aujourd'hui, elles mettent l'accent sur :
- Du logiciel fonctionnel plutôt que de la documentation exhaustive
- La réponse au changement plutôt que le suivi d'un plan
- Le logiciel fonctionnel est la principale mesure d'avancement
- Une attention continue à l'excellence technique et à une bonne
conception améliore l'agilité
- La simplicité est essentielle (il est facile de faire, il est
difficile de faire simple)
Le principe de base de la méthodologie Scrum par exemple est de focaliser l'équipe de façon
itérative sur un ensemble de fonctionnalités à réaliser, dans des itérations de durée fixe de une
à quatre semaines, appelées **sprints**. Chaque sprint possède un but à atteindre, défini par le
responsable de produit, à partir duquel sont choisies les fonctionnalités à implémenter dans ce
sprint. Un sprint aboutit toujours sur la livraison d'un produit partiel fonctionnel. Pendant ce
temps, le facilitateur a la charge de réduire au maximum les perturbations extérieures et de
résoudre les problèmes non techniques de l'équipe.

79
algo/algorithmique/cours/apercu.txt Normal file
View File

@ -0,0 +1,79 @@
Aperçu des algorithmes fondamentaux
===================================
Les algorithmes sont partout. Absolument partout aujourd'hui.
Il n'est pas un domaine de nos activités qui ne soit liés à tel ou tel algorithme.
En mathématiques
-----------------
- l'algèbre (étude des structures de données)
- l'arithmétique modulaire (théorie des nombres)
- la géométrie (affine, algébrique, invariants topologiques...)
- les diagrammes (diagrammes de Venn...)
- les colorisation d'une carte
- comportements stochastiques
En informatique
----------------
- les algorithmes sur la manipulation des structures de données
Exemple : les algorithmes de tri, de recherche dans un arbre...
- les parcours de graphes (chemins le plus court, voyageur de commerce...)
- la cryptologie (code gray)
- les stratégies de jeux
Tirés du monde réel
--------------------
- les jeux (casse-tête, dominos, échiquiers...)
- énigmes, logique et paradoxes
- problèmes de raisonnements. Il n'existe pas beaucoup de méthodes
ou de moyens simples pour traiter et résoudre les énoncés de logique de raisonnement.
- La "marche de l'ivrogne" : processus de progression discrète (pas à pas)
dont l'étape suivante est lié à l'état présent et pas du tout à la mémoire du passé proche.
Il revêt seulement un caractère de type probabilité (stochastique) dit markovien.
- algorithmes de colonies de fourmis (chemins optimal pour arriver à la nourriture)
Le voyageur de commerce
~~~~~~~~~~~~~~~~~~~~~~~~
Le problème du voyageur de commerce, consiste en la recherche d’un trajet minimal permettant à un
voyageur de visiter n villes. En règle générale on cherche à minimiser le temps de parcours total ou la
distance totale parcourue.
Il suffit de construire tous les chemins possibles et de calculer leurs longueurs.
Avec ``n`` villes il y a ``(n-1)!/2`` chemins possibles.
Avec 36 villes on trouve : 5166573983193072464833325668761600000000,
si le nombre de villes augmente, ça devient vite rédibitoire.
Résolution par
- algorithme de parcours de graphes
- algorithme glouton
- algorithmes génétiques
Les algorithmes génétiques s’appuient sur un principe de sélection des individus d’une population qui présen-
tent des caractéristiques se rapprochant au mieux de ce que l’on recherche; cette population évoluant par
ailleurs selon des critères d’évolution génétique à choisir. Dans le contexte du problème du voyageur de
commerce, un individu est une tournée, un chemin et une population un ensemble de tournées. Il s’agit
maintenant de dé...nir un critère de sélection ainsi que des règles d’évolution de la population.
- approches métaheuristiques (exemples: colonies de fourmis)
Exemple de résolution
.. raw:: latex
\begin{algorithm}
\caption{Algorithme du voyageur de commerce}\label{commerce}
\begin{algorithmic}[1]
\BState \emph{Données} : $L$ \Comment{Liste des villes à parcourir avec les distances entre les villes}
\BState \emph{Données} : $L'$ \Comment{Liste du parcours des villes à effectuer}
\State \emph{début}
\BState ...
\State \emph{fin}
\end{algorithmic}
\end{algorithm}

17
algo/algorithmique/cours/code/factorielle.ml Normal file
View File

@ -0,0 +1,17 @@
let rec fact = function
|1 -> 1
| n -> n * fact (n-1) ;;
let print_fact n =
Printf.printf "factorielle %i = %i\n" n (fact n)
let main () =
begin
print_fact 5 ;
print_newline () ;
exit 0 ;
end
let _ = main ()

12
algo/algorithmique/cours/code/factorielle.py Normal file
View File

@ -0,0 +1,12 @@
def factorielle(n):
if (n > 1):
r = n*factorielle(n-1)
else:
r = 1
return r
def print_fact(n):
print "factorielle {} = {}\n".format(5, factorielle(5))
if __name__ == '__main__':
print_fact(5)

370
algo/algorithmique/cours/conf.py Normal file
View File

@ -0,0 +1,370 @@
# -*- coding: utf-8 -*-
#
# Algorithmique documentation build configuration file, created by
# sphinx-quickstart on Thu Mar 16 16:07:00 2017.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys
import os
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.pngmath', 'sphinx.ext.ifconfig',
]
# ajout des cours avec solution des exercices ou non
def setup(app):
app.add_config_value('correction', False, 'env')
app.add_config_value('exercice', False, 'env')
exercice = False
correction = False
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
# source_suffix = ['.rst', '.md']
source_suffix = '.txt'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'Algorithmique'
copyright = u'2017, Gwen'
author = u'Gwen'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = u'1'
# The full version, including alpha/beta/rc tags.
release = u'1'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = 'fr'
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
today_fmt = '%d/%m/%Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# The reST default role (used for this markup: `text`) to use for all
# documents.
default_role = 'literal'
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
#keep_warnings = False
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'alabaster'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (relative to this directory) to use as a favicon of
# the docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#html_extra_path = []
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
html_show_sphinx = False
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
html_show_copyright = False
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
# 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
# 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
#html_search_language = 'en'
# A dictionary with options for the search language support, empty by default.
# Now only 'ja' uses this config value
#html_search_options = {'type': 'default'}
# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
#html_search_scorer = 'scorer.js'
# Output file base name for HTML help builder.
htmlhelp_basename = 'Algorithmiquedoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
'papersize': 'a4paper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
'preamble': """\usepackage{amsmath}
\usepackage{algorithm}
\usepackage[noend]{algpseudocode}
\makeatletter
\def\BState{\State\hskip-\ALG@thistlm}
\makeatother
"""
# Latex figure (float) alignment
#'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'Algorithmique.tex', u'Cours d\'algorithmique',
u'promotion GMSI B3', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
latex_logo = '_static/cesi.jpg'
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = False
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'algorithmique', u'Algorithmique Documentation',
[author], 1)
]
# If true, show URL addresses after external links.
#man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'Algorithmique', u'Algorithmique Documentation',
author, 'Algorithmique', 'One line description of project.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
#texinfo_no_detailmenu = False
# -- Options for Epub output ----------------------------------------------
# Bibliographic Dublin Core info.
epub_title = project
epub_author = author
epub_publisher = author
epub_copyright = copyright
# The basename for the epub file. It defaults to the project name.
#epub_basename = project
# The HTML theme for the epub output. Since the default themes are not
# optimized for small screen space, using the same theme for HTML and epub
# output is usually not wise. This defaults to 'epub', a theme designed to save
# visual space.
#epub_theme = 'epub'
# The language of the text. It defaults to the language option
# or 'en' if the language is not set.
#epub_language = ''
# The scheme of the identifier. Typical schemes are ISBN or URL.
#epub_scheme = ''
# The unique identifier of the text. This can be a ISBN number
# or the project homepage.
#epub_identifier = ''
# A unique identification for the text.
#epub_uid = ''
# A tuple containing the cover image and cover page html template filenames.
#epub_cover = ()
# A sequence of (type, uri, title) tuples for the guide element of content.opf.
#epub_guide = ()
# HTML files that should be inserted before the pages created by sphinx.
# The format is a list of tuples containing the path and title.
#epub_pre_files = []
# HTML files that should be inserted after the pages created by sphinx.
# The format is a list of tuples containing the path and title.
#epub_post_files = []
# A list of files that should not be packed into the epub file.
epub_exclude_files = ['search.html']
# The depth of the table of contents in toc.ncx.
#epub_tocdepth = 3
# Allow duplicate toc entries.
#epub_tocdup = True
# Choose between 'default' and 'includehidden'.
#epub_tocscope = 'default'
# Fix unsupported image types using the Pillow.
#epub_fix_images = False
# Scale large images.
#epub_max_image_width = 0
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#epub_show_urls = 'inline'
# If false, no index is generated.
#epub_use_index = True

294
algo/algorithmique/cours/control.txt Normal file
View File

@ -0,0 +1,294 @@
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}

577
algo/algorithmique/cours/donnees.txt Normal file
View File

@ -0,0 +1,577 @@
Les structures de données
===========================
.. glossary::
ATD
Abstract Data Type, structure de données abstraites.
La représentation des données est forcément un choix.
Il est impossible de rendre compte globalement d'un élément du réel,
il faut en faire une interprétation abstraite.
**Exemple**:
- Un être humain peut être représenté par les données présentes dans sa
carte d'identité. Mais un être humain n'est pas sa carte d'identité.
- Un être humain peut être représenté par les données présentes dans ses préférences
de surf sur internet. Mais un être humain **n'est pas** l'ensemble de ses logs de surf sur le net.
Les séquences
-------------
Les types séquences (listes)
.. code-block:: ocaml
# 4::1::5::8::1::[];;
- : int list = [4 ;1 ;5 ;8 ;1]
Un ensemble de valeurs portant le même nom de variable et repérées par un nombre, s’appelle un tableau, ou encore une liste, ou une variable indicée.
Le nombre qui, au sein d’un tableau, sert à repérer chaque valeur s’appelle l’indice.
Chaque fois que l’on doit désigner un élément du tableau, on fait figurer le nom du tableau, suivi de l’indice de l’élément.
**manipulation** :
- `insert()`
- `append()`
- `remove()`
- `find()`
- `print()`
- ...
.. code-block:: python
zoo = ['bear', 'lion', 'panda', 'zebra']
print(zoo)
# But these list elements are not
biggerZoo = ['bear', 'lion', 'panda', 'zebra', ['chimpanzees', 'gorillas', 'orangutans', 'gibbons']]
print(biggerZoo)
- Lists Versus Tuples : types mutables, immutables
- Lists Versus Sets : non ordonné, collection simple
- Recherche dans une liste, recherche du maximum dans une liste
- Recherche d’un mot dans une chaîne de caractères.
Algorithme de la longueur d'une liste
--------------------------------------
.. code-block:: ocaml
# let rec longueur l =
match l with
[] -> 0
| ::s -> 1 + (longueur s);;
Cette fonction est prédéfinie en Ocaml : `List.length`
.. ifconfig:: exercice
**Exercice** : écrire un algorithme qui déclare et
remplisse un tableau de 7 valeurs numériques en les mettant toutes à zéro.
.. ifconfig:: correction
**Correction** :
::
Tableau Truc(6) en Numérique
Variable i en Numérique
Debut
Pour i <- 0 à 6
Truc(i) <- 0
i Suivant
Fin
exemple d'implémentation en python
.. code-block: python
>>> liste = []
>>> for i in range(6):
... liste.append(i)
...
>>> liste
[0, 1, 2, 3, 4, 5]
>>>
.. ifconfig:: exercice
**Exercice** : Calcul du premier élément maximal dans une liste,
proposer une implémentation en python qui renvoie le maximum et
la position du max dans la liste.
.. ifconfig:: correction
**Correction** :
.. code-block: python
def max_list(L) :
k = len(L)
max, x = L[0], 0
i = 1
while i < k :
if max < L[i]:
max = L[i]
x = i
i = i + 1
return max, x
couple = max_list([4,5,6,9,12,5,10,3,18,5,6,7])
print ’Max de L est ’, couple[0]
print ’et se trouve à la position ’, couple[1]
Exemple de généricité : ce code fonctionne avec une chaîne de caractères.
.. code-block: python
couple = max_list(’totovaaumarche’)
print ’Max de L est ’, couple[0]
print ’et se trouve à la position ’, couple[1]
.. glossary::
Matrice
Tableaux de dimension multiple, c'est un tableau de tableau
.. ifconfig:: exercice
**Exercice** : Écrivez un algorithme remplissant un tableau de 6 sur 13, avec des zéros.
.. ifconfig:: correction
**Correction** :
implémentation en python
.. code-block:: python
>>> matrice = []
>>> for i in range(12):
... matrice.append([0 for i in range(5)])
...
>>> from pprint import pprint
>>> pprint(matrice)
[[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]]
>>>
Algorithmes de tri
------------------
On désigne par "tri" l'opération consistant à ordonner un ensemble d'éléments en fonction de clés sur lesquelles est définie une relation d'ordre.
Les algorithmes de tri ont une grande importance pratique.
Ils sont fondamentaux dans certains domaines (exemples : map-reduce en database non relationnelle).
L'étude du tri est également intéressante en elle-même, c'est un des domaines de l'algorithmique très étudié et connu.
Tri par insertion
~~~~~~~~~~~~~~~~~~
Cet algorithme de tri suit de manière naturelle la structure récursive des
listes. Soit l une liste à trier :
- si l est vide alors elle est déjà triée
- sinon, l est de la forme x::s et on trie récursivement la suite s et on obtient une liste triée s’
on insert x au bon endroit dans s’ et on obtient une liste triée
Description de l'algorithme
- la fonction inserer permet d’insérer un élément x dans une liste l
- si la liste l est triée alors x est inséré au bon endroit
.. code-block:: ocaml
# let rec inserer x l =
match l with
[] -> [x]
| y::s -> if x<=y then x::l else y::(inserer x s);;
val inserer : ’a -> ’a list -> ’a list
# inserer 5 [3 ;7 ;10];;
- : int list = [3 ; 5 ; 7 ; 10]
Tri rapide
~~~~~~~~~~~~
soit une liste l à trier :
- si l est vide alors elle est triée
- sinon, choisir un élément p de la liste (le premier par exemple)
nommé le **pivot**
- partager l en deux listes g et d contenant les autres éléments de l
qui sont plus petits (resp. plus grands) que la valeur du pivot p
- trier récursivement g et d, on obtient deux listes g’ et d’ triées
.. code-block:: ocaml
:caption: fonction de partage d'une liste
#let rec partage p l =
match l with
[] -> ([] , [])
|x::s -> let g,d = partage p s in
if x<=p then (x::g , d) else (g , x::d) ;;
val partage : ’a -> ’a list -> ’a list * ’a list = <fun>
# partage 5 [1 ;9 ;7 ;3 ;2 ;4];;
- : int list * int list = ([1 ; 3 ; 2 ; 4], [9 ; 7])
.. code-block:: ocaml
:caption: algorithme de tri rapide
# let rec tri rapide l =
match l with
[] -> []
| p::s -> let g , d = partage p s in
(tri rapide g)@[p]@(tri rapide d) ;;
val tri rapide : ’a list -> ’a list = <fun>
# tri rapide [5 ; 1 ; 9 ; 7 ; 3 ; 2 ; 4];;
- : int list = [1 ; 2 ; 3 ; 4 ; 5 ; 7 ; 9]
Définition d'un itérateur
~~~~~~~~~~~~~~~~~~~~~~~~~~
.. code-block:: python
>>> l = range(10)
>>> for i in l:
... print l[i]
...
0
...
8
9
>>> l.__iter__()
<listiterator object at 0x7f78bb450410>
Les listes chaînées
~~~~~~~~~~~~~~~~~~~~
.. code-block:: ocaml
typedef struct list{
int elt ;
struct list* suivant ;
} ;
**Outils de manipulation** :
- `next()`
- `pointer()`
- `insert(l, a)`
- `remove(a, n)`
Les piles
----------
**manipulation**
- `insert()` : insérer un élément à la fin de la pile
- `dequeue()` : (remove and return) : retirer un élément du haut de la pile
- FIFO : "first in first out"
Traduction d'une structure de données dans une autre
-----------------------------------------------------
.. code-block:: python
>>> listOfStrings = ['One', 'Two', 'Three']
>>> strOfStrings = ' '.join(listOfStrings)
>>> print(strOfStrings)
One Two Three
>>>
>>> # List Of Integers to a String
... listOfNumbers = [1, 2, 3]
>>> strOfNumbers = ''.join(str(n) for n in listOfNumbers)
>>> print(strOfNumbers)
123
>>>
.. code-block:: python
>>> l = [('host1', '10.1.2.3', '6E:FF:56:A2:AF:18'), ('host3', '10.1.2.5', '6E:FF:56:A2:AF:19')]
>>> result = []
>>> for hostname, ip, macaddress in l:
... result.append(dict(hostname=hostname, ip=ip, macaddress=macaddress))
...
>>> result
[{'hostname': 'host1', 'ip': '10.1.2.3', 'macaddress': '6E:FF:56:A2:AF:18'},
{'hostname': 'host3', 'ip': '10.1.2.5', 'macaddress': '6E:FF:56:A2:AF:19'}]
>>>
.. ifconfig:: exercice
**Exercice** : Proposer un algorithme de traduction de cette structure de donnée
.. code-block:: python
[
{
'address': '192.168.0.0',
'mask': '255.255.255.0',
'dynamicRanges': [
{ 'low': '192.168.0.5', 'high': '192.168.0.12', 'only_unknown': True },
{ 'low': '192.168.0.50', 'high': '192.168.0.55', 'only_unknown': False },
],
},
{
'address': '192.168.0.0',
'mask': '255.255.255.0',
'dynamicRanges': [
{ 'low': '192.168.0.12', 'high': '192.168.0.45', 'only_unknown': True },
{ 'low': '192.168.0.8', 'high': '192.168.0.35', 'only_unknown': False },
],
},
{
'address': '192.168.0.1',
'mask': '255.255.255.0',
'dynamicRanges': [
{ 'low': '192.168.0.5', 'high': '192.168.0.12', 'only_unknown': True },
{ 'low': '192.168.0.50', 'high': '192.168.0.55', 'only_unknown': False },
],
},
]
En cette structure de données :
.. code-block:: python
[
{
address: '192.168.0.0',
mask: '255.255.255.0',
dynamicRanges: [
{ low: '192.168.0.5', high: '192.168.0.12', only_unknown: true },
{ low: '192.168.0.50', high: '192.168.0.55', only_unknown: false },j
], [
{ low: '192.168.0.12', high: '192.168.0.45', only_unknown: true },
{ low: '192.168.0.8', high: '192.168.0.35', only_unknown: false },
],
},
{
'address': '192.168.0.1',
'mask': '255.255.255.0',
'dynamicRanges': [
{ 'low': '192.168.0.5', 'high': '192.168.0.12', 'only_unknown': True },
{ 'low': '192.168.0.50', 'high': '192.168.0.55', 'only_unknown': False },
],
},
]
.. ifconfig:: correction
**Correction** :
.. code-block:: python
>>> from pprint import pprint
pprint(l)
[{'address': '192.168.0.0',
'dynamicRanges': [{'high': '192.168.0.12',
'low': '192.168.0.5',
'only_unknown': True},
{'high': '192.168.0.55',
'low': '192.168.0.50',
'only_unknown': False}],
'mask': '255.255.255.0'},
{'address': '192.168.0.0',
'dynamicRanges': [{'high': '192.168.0.45',
'low': '192.168.0.12',
'only_unknown': True},
{'high': '192.168.0.35',
'low': '192.168.0.8',
'only_unknown': False}],
'mask': '255.255.255.0'}]
>>> newdata = []
>>> for i in l:
... if i['address'] not in [j['address'] for j in newdata]:
... newdata.append(i)
... else:
... for k in newdata:
... if k['address'] == i['address']:
... k['dynamicRanges'].extend(i['dynamicRanges'])
...
>>> pprint(newdata)
[{'address': '192.168.0.0',
'dynamicRanges': [{'high': '192.168.0.12',
'low': '192.168.0.5',
'only_unknown': True},
{'high': '192.168.0.55',
'low': '192.168.0.50',
'only_unknown': False},
{'high': '192.168.0.45',
'low': '192.168.0.12',
'only_unknown': True},
{'high': '192.168.0.35',
'low': '192.168.0.8',
'only_unknown': False}],
'mask': '255.255.255.0'},
{'address': '192.168.10.0',
'dynamicRanges': [{'high': '192.168.0.12',
'low': '192.168.0.5',
'only_unknown': True},
{'high': '192.168.0.55',
'low': '192.168.0.50',
'only_unknown': False}],
'mask': '255.255.255.0'}]
>>>
.. ifconfig:: exercice
**Exercice** : Proposer un algorithme qui permette de récupérer la liste
des adresses IP disponibles
.. code-block:: python
{
"local": {
"leases": [
{
"mac": "02:00:c0:a8:00:66",
"name": "pcxubuntu",
"address": "192.168.0.200"
},
{
"mac": "02:00:c0:a8:00:67",
"name": "pcxubuntu",
"address": "192.168.0.201"
},
{
"mac": "02:00:c0:a8:00:68",
"name": "pcxubuntu",
"address": "192.168.0.202"
}
]
}
}
.. ifconfig:: correction
**Correction** :
.. code-block:: python
>>> l = {
... "local": {
... "leases": [
... {
... "mac": "02:00:c0:a8:00:66",
... "name": "pcxubuntu",
... "address": "192.168.0.200"
... },
... {
... "mac": "02:00:c0:a8:00:67",
... "name": "pcxubuntu",
... "address": "192.168.0.201"
... },
... {
... "mac": "02:00:c0:a8:00:68",
... "name": "pcxubuntu",
... "address": "192.168.0.202"
... }
... ]
... }
... }
>>> leases = l["local"]["leases"]
>>> from pprint import pprint
>>> pprint(leases)
[{'address': '192.168.0.200', 'mac': '02:00:c0:a8:00:66', 'name': 'pcxubuntu'},
{'address': '192.168.0.201', 'mac': '02:00:c0:a8:00:67', 'name': 'pcxubuntu'},
{'address': '192.168.0.202', 'mac': '02:00:c0:a8:00:68', 'name': 'pcxubuntu'}]
>>> addresses = [lease['address'] for lease in leases]
>>> addresses
['192.168.0.200', '192.168.0.201', '192.168.0.202']
>>>
Structures de données complexes
-------------------------------
Les types produits nommés
~~~~~~~~~~~~~~~~~~~~~~~~~~
On les appelle enregistrements, dictionnaires ou tables de hachage.
::
algorithme monAlgorithme
// déclaration d'un enregistrement
enregistrement Personne
chaine nom;
chaine prenom;
entier age;
réel taille;
finenregistrement
...
Personne[50] t;
début
// Initialisation
t[0].nom <- "Duchmol";
t[0].prenom <- "Robert";
t[0].age <- 24;
t[0].taille <- 1.80;
...
fin
.. code-block:: ocaml
# type adresse = { rue : string ; ville : string ; cp : int};;
# type fiche = {
nom : string ;
prenom : string ;
adresse : adresse ;
date naissance : int * int * int ;
tel fixe : string ;
portable : string
};;
# let v1 = { a = 1 ; b = false ; c = 'r'};;
- les sommes (constructeurs)
.. code-block:: ocaml
# type couleur = Pique | Coeur | Carreau | Trefle;;
# let v = (Pique , Coeur);;
val v : couleur * couleur = (Pique , Coeur)
.. code-block:: ocaml
type nombre =
Ent of int | Reel of float | Cplx of float × float
Ent, Reel, Cplx sont les constructeurs du type.
Autres structures de données complexes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- arbres
- graphes
- dates
- le parcours de graphes
- les calculs de dates

2
algo/algorithmique/cours/fonctions.txt Normal file
View File

@ -0,0 +1,2 @@
.. include:: ../../tronCommun/fonctions.txt

198
algo/algorithmique/cours/fondement.txt Normal file
View File

@ -0,0 +1,198 @@
Présentation de l'art de programmer
====================================
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

19
algo/algorithmique/cours/index.txt Normal file
View File

@ -0,0 +1,19 @@
Introduction à l'algorithmique
================================
.. toctree::
:maxdepth: 2
presentation
fondement
langage
algo
programme
fonctions
control
donnees
apercu
modularite
modules
tp
annexes/index

1
algo/algorithmique/cours/langage.txt Normal file
View File

@ -0,0 +1 @@
.. include:: ../../tronCommun/langage.txt

200
algo/algorithmique/cours/modularite.txt Normal file
View File

@ -0,0 +1,200 @@
La programmation structurée
=============================
Un langage de programmation doit permettre la programmation structurée.
.. important:: La structuration et l'organisation modulaire sert à maintenir de grands programmes,
Elles sont une nécessité
Structuration d'un programme
-----------------------------
La réalisation d'applications importantes oblige le programmeur ou l'équipe de
développement à se poser des questions d'organisation et de structuration.
Aujourd'hui, on dispose de deux grands modèles d'organisation dont les avantages et les
particularités sont distincts.
L'écriture des vrais programmes consiste à les structurer pour les présenter
comme un assemblage de briques qui s'emboîtent naturellement.
Ce problème se révèle fondamental dès que la taille des programmes devient conséquente.
Si on ne prend pas garde au bon découpage des programmes en modules indépendants,
on se retrouve rapidement débordé par un grand nombre de variables,
et il devient quasiment impossible de réaliser un programme correct.
La programmation raisonnée
---------------------------
Un **programme** est le codage d'un algorithme dans un langage de programmation.
La programmation consiste à modéliser un problème du monde réel sous une forme
symbolique (pour faire résoudre ce problème par un ordinateur).
Certains problèmes sont **indécidables** ou **ouverts**.
On utilise un langage de programmation pour décrire la **solution** du programme.
La sémantique du programme est le sens de chacune des constructions du langage.
**Comment passer de l'énoncé d'un problème à un programme de bonne qualité ?**
spécifier
décrire de manière complète et rigoureuse le problème à résoudre
modéliser
proposer une représentation du réel qui soit accessible au calcul
algorithmique
transcrire
La transcription du modèle algorithmique se fait dans un langage
de programmation cible adapté au problème
valider
La validation du programme est une étape qui permet de s'assurer plus ou
moins fortement que le programme produit les résultats attendus.
La validation va de la série de tests unitaires (validation faible)
à la preuve de programme (validation mathématique forte).
Conception descendante
-----------------------
Une vision **centripète** : du général au particulier.
Il s'agit d'une méthode de résolution d'un problème. On le découpe en tâches
de plus en plus fines, de plus en plus détaillées, qui aboutiront au programme final.
On met des *trous* dans les algorithmes de plus haut niveau,
c'est-à-dire des phrases en langage naturel.
.. ifconfig: exercice
**Exercice** : **Calculer la date du lendemain**
.. ifconfig: correction
- l'algorithme de plus bas niveau
::
lendemain jour =
si jour [est le dernier jour du mois] alors
resultat = [calculer le 1er janvier de l'année suivante]
sinon
resultat = lendemain_dansl'année jour
- les algorithmes de plus bas niveau
::
lendemain_dans_l'année jour =
si jour [est le dernier jour du mois] alors
resultat = [calculer le premier jour du mois suivant]
sinon
resultat = jour suivant jour
::
jour_suivant jour =
jour + 1
et ainsi de suite jusqu'à ce que toutes les phrases soient calculables.
Algorithme vague
--------------------
L'algorithme vague, c'est quand on pense l'algorithme en se plaçant du côté de
l'implémentation en premier. On a le nez dans le guidon, la vue d'ensemble est
difficile.
Voici, tiré du monde réel, un exemple d'algorithme vague
("ce que doit faire une fonction"), placé dans un bout de code
(souvent la **docstring** d'une fonction).
.. code-block:: python
def upsert_route(*args, **kwargs):
"""
Create or modify an existant DHCP route
param tuple (id or null, machine name, IP, MAC Adress)
return True or False with error message
"""
# si id présent alors modification sinon ajout
# récupère la liste des réservations en cours
# y cherche la variable sur la base de l'ID
# modifie les valeurs
# applique la nouvelle conf DHCP
return True
Voici un autre bout de code avec l'algorithme en commentaire,
et l'implémentation effective de l'algorithme
.. code-block:: python
def del_route(*args, **kwargs):
"""
Delete an existant DHCP route
param tuple (id, machine name, IP, MAC Adress)
return True or False with error message
"""
# récupère la liste des réservations en cours
# y cherche la variable sur l'id donné en paramètre
# supprime l'entrée avec vérification que les données fournies
# sont bien dans l'enregistrement à supprimer
# applique la nouvelle conf DHCP
route_to_del = (1, "host2","10.1.2.4","6E:FF:56:A2:AF:17")
routes = get_routes()
if route_to_del in routes:
c = creole_loader(load_extra=True, rw=True)
c_id = c.dhcp.dhcp.id_dhcp.id_dhcp.index(route_to_del[0])
if c.dhcp.dhcp.id_dhcp.macaddress[c_id]==route_to_del[2]
and c.dhcp.dhcp.id_dhcp.ip[c_id]==route_to_del[1]:
c.dhcp.dhcp.id_dhcp.id_dhcp.pop(c_id)
config_save_values(c, MODNAME)
return True
return False
Les deux grands paradigmes
---------------------------
La modularité
~~~~~~~~~~~~~~
Les données et les traitements sont regroupés au sein d'une même entité à deux
facettes : d'un côté le code proprement dit, de l'autre son interface. La
communication entre modules s'effectue via leur interface. La description d'un
type peut être masquée en n'apparaissant pas dans l'interface du module. Ces
types de données abstraits facilitent les modifications d'implantation à
l'intérieur d'un module sans affecter les autres modules qui s'en servent. De
plus, les modules peuvent être paramétrés par d'autres modules augmentant
ainsi leur réutilisabilité.
Le paradigme objet
~~~~~~~~~~~~~~~~~~
Les descriptions des traitements et des données sont regroupées dans des
entités appelées **classes**; un objet est une instance (valeur) d'une classe.
La communication entre objets est réalisée par envoi de message, l'objet
receveur détermine à l'exécution (liaison retardée) le traitement
correspondant au message. En cela, la programmation objet est dirigée par
les données. La structuration d'un programme provient des relations entre
classes, en particulier l'héritage permet de définir une classe par extension
d'une autre.
En programmation objet, un **programme** est une collection d’objets qui communiquent
entre eux par **message**, le **résultat** est un message envoyé à un objet particulier
Comparaison entre les deux paradigmes
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Il y a dualité entre ces deux modèles.
- On ne peut pas augmenter les composants d'un type dans un module (pas
d'extensibilité des données), mais on peut ajouter de nouveaux traitements
(extensibilité des traitements) sur ces données.
- En objet, on peut ajouter des sous-classes à une classe (extensibilité des
données) pour traiter des nouveaux cas, mais on ne peut pas ajouter de nouveaux
traitements visibles de la classe ancêtre (pas d'extensibilité des traitements).
**La combinaison des deux paradigmes offre de nouvelles extensibilités pour les
traitements et les données.**

313
algo/algorithmique/cours/modules.txt Normal file
View File

@ -0,0 +1,313 @@
La programmation modulaire
===========================
Il s'agit de décomposer un grand programme en
morceaux (**modules**) connectés entre eux par des **interfaces** bien
définies.
Ces modules doivent être aussi indépendants que possible.
module
ensemble de ressources liées sémantiquement
interface
mode d’emploi du module, avec en plus un principe de masquage
des informations (partie publique, partie secrète)
Signatures, type abstrait et langage de modules : la programmation modulaire
permet d'aller très loin dans la programmation structurée.
Définir des fonctions dans un fichier séparé
--------------------------------------------
Les fonctions peuvent être définies dans un fichier et le programme dans un
autre fichier séparé. Dans ce cas, pour pouvoir être exécuté directement avec
la commande python `nomfichierprogramme.py`, le fichier du programme doit
importer d’abord les fonctions du fichier dans lequel les fonctions sont
définies.
1. Fichier de fonctions
~~~~~~~~~~~~~~~~~~~~~~~~
.. code-block:: python
# Fichier foncmaxliste.py
# Recherche le premier élément maximal dans une liste ou
#dans une chaine de caractères
def max_list(L) :
k = len(L)
max, x = L[0], 0
i = 1
while i < k :
if max < L[i]:
max = L[i]
x = i
i = i + 1
return max, x
2. Fichier de programme
~~~~~~~~~~~~~~~~~~~~~~~~
Pour utilser les fonctions définies dans d’autres fichiers, le fichier de
programme doit commencer par les instructions qui importent ces fichiers de
fonctions ou directement les fonctions de ces fichiers. Dans la syntaxe
ci-dessous, on importe une ou toutes les fonctions du fichier `foncmaxlist.py`.
.. code-block:: python
# Fichier progmaxlist.py
from foncmaxliste import max_list
# ou plus simple:
# from foncmaxliste import *
print max_list([4,5,6,9,12,5,10,3,18,5,6,7])
couple = max_list([4,5,6,9,12,5,10,3,18,5,6,7])
print ’Max de L est ’, couple[0]
print ’et se trouve à la position ’, couple[1]
print max_list(’totovaaumarche’)
couple = max_list(’totovaaumarche’)
print ’Max de L est ’, couple[0]
print ’et se trouve à la position ’, couple[1]
Au lieu d’importer les fonctions, on peut importer le fichier qui définit les
fonctions avec la syntaxe qui suit. Dans ce cas, le fichier de programme sera
changé comme suit :
.. code-block:: python
# Fichier prog2maxlist
import foncmaxliste
print foncmaxliste.max_list([4,5,6,9,12,5,10,3,18,5,6,7])
# la syntaxe indiquant le chemin d’acces a la fonction max_list utiliser ‘‘.’’
couple = foncmaxliste.max_list([4,5,6,9,12,5,10,3,18,5,6,7])
print ’Max de L est ’, couple[0]
print ’et se trouve à la position ’, couple[1]
print foncmaxliste.max_list(’totovaaumarche’)
couple = foncmaxliste.max_list(’totovaaumarche’)
print ’Max de L est ’, couple[0]
print ’et se trouve à la position ’, couple[1]
L’exécution directe du premier fichier de programme::
python prog max list.py
L’exécution directe du seconde fichier de programme::
python prog2 max list.py
Définition de l'implémentation d'un module
-------------------------------------------
Tout fichier qui contient au moins une définition d’une fonction ou d’une
variable est appelé un module (une bibliothèque). Le nom du module est le nom
du fichier enlevé le suffixe `.py`. Ainsi, un fichier de programme qui contient
au moins une définition d’une fonction ou un fichier qui ne contient que des
définition de fonctions sont des modules. On peut importer un module ou des
fonctions ou variables d’un module dans un programme, comme nous avons vu dans
les exemples ci-dessus.
.. important:: on peut importer un module, ou bien lancer un module en tant que
programme executable
.. code-block:: python
if __name__ == '__main__':
main()
Pour faciliter la programmation, Python définit un certain nombre de **modules internes**,
appelés les builtins (la librairie standard).
Par exemple :
– Lors de l’ouverture d’une session interactive, on est dans un module interne nommé
main . Toutes les variables définies par affectation au niveau de ce module sont valides
globalement dans la session.
– D’autres modules internes sont string, math, random
Dans une session de travail sous l’interpréteur Python, la première importation d’un mo-
dule qui, à part des fonctions qu’elle définit, contient des instruction de programme fait
exécuter ces instructions. Dans la même session, les importations suivantes ne font pas
exécuter ces instructions. Pour les exécuter, on utilise la fonction reload(nomdumodule)
(sans sufffixe .py).
Exemples d'interface
--------------------
::
type: son type
arguments
arg1 : description de l'argument 1
arg2 : description de l'argument 2
préconditions:
arg1 > 10
postconditions:
result < 19
raises: TypeError, AssertionError, SystemError...
test: tests nominaux pour chaque cas spécifié
- L'interface racine carrée
::
racine:
type: float -> float
arguments x: float, flottant dont on veut calculer la racine
pré: x >= 0
test: racine 25.0 -> 5.0 ; racine (-25) -> raises TypeError
- L'interface `lendemain`
Il faut définir auparavant un type spécifique appelé `date`
::
lendemain: le lendemain est la date qui désigne
le jour suivant de la date passée en argument
type: date -> date
arguments :
d: date
description: la date dont on veut calculer le lendemain
Le langages des modules
-------------------------
.. code-block:: ocaml
module type PILE = (* signature (interface) du module *)
sig
type ’a t
val create : unit -> ’a t
val push : ’a -> ’a t -> unit
val pop : ’a t -> ’a
end
(* implémentation du module *)
module Pile : PILE = (* le module est restreint
par la signature PILE *)
struct
type ’a t = ’a list ref
let create () = ref []
let push x p = p := x::!p
let pop p = match !p with [...]
let rec print p = match p with [...]
end
- `struct .. end` introduit une collection de définitions, valeurs, types ou modules.
C'est une **structure**.
- `module Nom = struct .. end` permet de donner un nom à cette structure et
c'est ça un module. C'est une structure nommée.
- `sig ... end` introduit une signature de module : une interface pour un module.
On restreint souvent une structure par une signature pour "cacher" certaines
définitions. Une signature de module fournit une **interface** entre l'extérieur
et l'intérieur d'un module.
En dehors du module, on accède à ses composants grâce à la notation pointée
.. code-block:: ocaml
let p = Pile.create()
Pile.push 45 p
Les foncteurs
--------------
Si un langage possède un langage de modules, on peut aller plus loin : on peut
considérer un module comme étant une expression de base du langage.
- La signature d'un module peut être considérée comme le type du module
- La structure du module peut être considéré comme sa valeur
Quel est l'intérêt ? On peut alors définir des **foncteurs**.
foncteur
"fonction" d'une structure vers une autre structure.
On peut ainsi paramétrer un module par un autre module.
.. code-block:: ocaml
module Nom (M1 :S1 ) (M2 :S2 ) (M3 :S3 ) ... =
struct
...
end
On applique un foncteur à des paramètres modules, pour
obtenir un nouveau module :
.. code-block:: ocaml
module M = F (Titi) (Toto)
Contrainte de type par signature
------------------------------------
::
module M =
struct
type t = int * int * int ;;
let make d m y = d, m, y ;;
end ;;
let d = M.make 8 5 8 ;;
module type S =
sig
type t ;;
val make : int -> int -> int -> t ;;
end ;;
module MS = (M:S) ;;
MS.make 5 1 2 ;;
Type et signature
------------------
::
# module type A = sig
val a: int -> int
end ;;
module type A = sig val a : int -> int end
# module B = struct
let a x = x + 1 ;;
end;;
module B : sig val a : int -> int end
# module C = (B:A) ;;
module C : A
# C.a 2 ;;
- : int = 3
#
Module auquel on impose une signature
-----------------------------------------
::
module type DATE = sig
type t
val make: int -> t
val get_year: t -> int
val get_month: t -> int
end ;;
module MR = struct
type t = int * int
let make x y = (x, y)
let get_month (x, y) = x
let get_year (x, y) = y
end ;;
module date = (MR:DATE) ;;

22
algo/algorithmique/cours/presentation.txt Normal file
View File

@ -0,0 +1,22 @@
Avant propos
============
.. include:: ../../tronCommun/presentation.txt
Objectifs de ce cours
~~~~~~~~~~~~~~~~~~~~~
Il s'agit de :
- maîtriser et concevoir un algorithme de base,
- choisir une représentation appropriée des données,
- décomposer en sous-problèmes et affinements successifs,
- savoir organiser son code en fonctions et en modules.
Le développement raisonné d’algorithmes et leur implantation
permet d'acquérir les qualités suivantes :
+ Analyser et modéliser un problème, spécifier,
+ Exprimer une problématique, une solution ou un algorithme,
+ Traduire un algorithme dans un langage de programmation,
+ Concevoir une réponse à un problème précisément posé.

2
algo/algorithmique/cours/programme.txt Normal file
View File

@ -0,0 +1,2 @@
.. include:: ../../tronCommun/programme.txt

101
algo/algorithmique/cours/tp.txt Normal file
View File

@ -0,0 +1,101 @@
Travaux Pratiques
=================
.. ifconfig:: exercice
**travaux pratiques :**
Ecrire un algorithme qui renvoie le résultat d’une mini-calculatrice. Cette
méthode aura
comme paramètre deux nombres et une chaîne de caractère qui vaudra « + », « -
», « * »,
« / ».
.. ifconfig:: exercice
**travaux pratiques :**
Ecrire un algorithme qui renvoie si deux mots (chaîne de caractères) passés en
paramètre
sont des anagrammes l’un de l’autre. (Lettres identiques mais dans un ordre
différent)
.. ifconfig:: exercice
**travaux pratiques :**
ascii art (ligne d'étoiles)
Concevoir un algorithme qui, pour un caractère imprimable et un nombre n
donnés, imprime une barre
horizontale de n de ces caractères.
``****************``
2. Modifier l’algorithme pour l’impression d’une barre double.
::
****************
****************
3. Modifier l’algorithme pour l’impression d’une barre d’épaisseur quelconque
donnée.
4. (optionnel) Transformer les algorithmes ci-dessus en fonctions.
5. Écrire un programme Java implémentant la dernière version de l’algorithme
(épaisseur quelconque).
3.3
Triangle de nombres
Concevoir un algorithme qui imprime pour n donné::
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
...........
.............
...............
1 2 3 4 5 6 ... n
.. ifconfig:: exercice
**travaux pratiques :**
code de césar : faire un programme pour chiffrer et déchiffrer par décalage
exemples : Effectue une rotation de x caractères vers la droite::
>>> print(chiffre('bonjour', 3))
erqmrxu
>>> print(chiffre('Bonjour les amis!', 3))
Erqmrxu ohv dplv!
>>> print(chiffre('Erqmrxu ohv dplv!', 23))
Bonjour les amis!
.. ifconfig:: exercice
**travaux pratiques :**
::
écrire “Entrer un numéro de mois”
mois <- lire
selon que mois est
cas 1 : écrire “janvier (31 jours)”
cas 2 : écrire “février (28 ou 29 jours)”
cas 3 : écrire “mars (31 jours)”
cas 4 : écrire “avril (30 jours)”
cas 5 : écrire “mai (31 jours)”
cas 6 : écrire “juin (30 jours)”
cas 7 : écrire “juillet (31 jours)”
cas 8 : écrire “août (31 jours)”
cas 9 : écrire “septembre (30 jours)”
cas 10 : écrire “octobre (31 jours)”
cas 11 : écrire “novembre (30 jours)”
cas 12 : écrire “décembre (31 jours)”
défaut : écrire “numéro invalide”
fselon