utilisation de l'extension ifconfig pour les exercices et les corrections

This commit is contained in:
gwen 2017-04-11 14:23:52 +02:00 committed by Benjamin Bohard
parent a6f960e6bc
commit 5c2ec45681
7 changed files with 204 additions and 22 deletions

View File

@ -269,7 +269,6 @@ Comment rendre un algorithme lisible
- Le bon algorithme est structuré. - Le bon algorithme est structuré.
- Le bon algorithme est indenté. - Le bon algorithme est indenté.
Complexité d'un algorithme Complexité d'un algorithme
-------------------------- --------------------------
@ -278,5 +277,10 @@ C'est utile pour pouvoir comparer des algorithmes.
complexité complexité
estimer la complexité d'un algorithme, estimer la complexité d'un algorithme, c'est estimer le nombre de calculs qu'il utilise.
c'est-à-dire estimer le nombre de calculs qu'il utilise.
Si f est la fonction caractérisant exactement le coût dun algorithme et n
la taille des données, on sintéresse à la façon dont augment f(n) lorsque n augmente
on va montrer que f(n) n'augmente pas plus vite quune 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)

View File

@ -11,6 +11,10 @@ Première journée : Le langage Python
| Recherche dun mot dans une chaîne de caractères. | On se limite ici à lalgorithme "naïf", en estimant sa complexité. | | Recherche dun mot dans une chaîne de caractères. | On se limite ici à lalgorithme "naïf", en estimant sa complexité. |
+------------------------------------------------------+------------------------------------------------------------------------+ +------------------------------------------------------+------------------------------------------------------------------------+
.. ifconfig:: correction
bla bla bla
Séance 1 : Un apercu des possibles utilisations de Python Séance 1 : Un apercu des possibles utilisations de Python
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

View File

@ -29,9 +29,15 @@ import os
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones. # ones.
extensions = [ extensions = [
'sphinx.ext.pngmath', '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')
correction = True
# Add any paths that contain templates here, relative to this directory. # Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates'] templates_path = ['_templates']

View File

@ -1,8 +1,8 @@
Les tructures de contrôle Les structures de contrôle
========================== ==========================
L'instruction de saut conditionnel L'instruction de saut
---------------------------------- ----------------------
.. raw:: latex .. raw:: latex
@ -53,9 +53,10 @@ Description générique d'une instruction de saut::
dans le langage cible, car c'est le meilleur moyen d'aboutir à dans le langage cible, car c'est le meilleur moyen d'aboutir à
du **code spaghetti**. du **code spaghetti**.
L'instruction de test L'instruction de branchement conditionnel
~~~~~~~~~~~~~~~~~~~~~~ ------------------------------------------
On appelle structure conditionnelle les instructions qui permettent de tester si une condition est vraie ou non.
.. raw:: latex .. raw:: latex
@ -81,13 +82,22 @@ L'instruction de test
\end{algorithm} \end{algorithm}
Les boucles 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 .. important:: Toutes les boucles concernent le paradigme de programmation impératif
et ne sont pas valides dans le paradigme de programmation fonctionnel et ne sont pas valides dans le paradigme de programmation fonctionnel
(puisque l'ordre d'évaluation importe) (puisque l'ordre d'évaluation importe)
- arrêt conditionnel (break)
- passage d'un pas (continue)
Répéter ... jusqu'à Répéter ... jusqu'à
~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~
@ -137,3 +147,20 @@ La boucle tant que (while)
\EndWhile \EndWhile
\end{algorithmic} \end{algorithmic}
\end{algorithm} \end{algorithm}
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}

View File

@ -28,6 +28,8 @@ Un langage de programmation doit permettre :
Approche historique et chronologique Approche historique et chronologique
------------------------------------- -------------------------------------
- Lambda calcul (1930)
- machines de Turing (1936)
- début des langages vers les années 1950 (A0, Fortran(impératif), - début des langages vers les années 1950 (A0, Fortran(impératif),
Lisp(impératif et fonctionnel), Cobol) Lisp(impératif et fonctionnel), Cobol)
- années 60 : Simula (classes), CPL (compilation séparée) - années 60 : Simula (classes), CPL (compilation séparée)

View File

@ -1,7 +1,6 @@
Introduction à la modularité Introduction à la modularité
============================= =============================
Un langage de programmation doit permettre 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, .. important:: La structuration et l'organisation modulaire sert à maintenir de grands programmes,

View File

@ -45,6 +45,9 @@ Par exemple, la ligne suivante est une expression effectuant une addition::
5 + 6 5 + 6
Expressions à partir de types de base
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Autres exemples d'expressions : Autres exemples d'expressions :
- 5 est une expression de type int - 5 est une expression de type int
@ -54,6 +57,142 @@ Autres exemples d'expressions :
- print ('c') est une expression de type None - print ('c') est une expression de type None
- raw_input est une expression de type string - raw_input est une expression de type string
Expressions à partir de types produits
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Les types construits permettent de structurer linformation.
- les produits (n-uplets)
.. code-block:: ocaml
# type complexe = float * float ;;
- les produits nommés (enregistrements)
.. 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.
On voit qu'une expression peut-être complexe, mais dans tous les cas une valeur
est renvoyée.
- les types séquences (listes)
.. code-block:: ocaml
# 4::1::5::8::1::[];;
- : int list = [4 ;1 ;5 ;8 ;1]
Algorithme de la longeur 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`
Algorithme de 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 dinsé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]
Algorithme de 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]
Les listes chaînées
~~~~~~~~~~~~~~~~~~~~
.. code-block:: ocaml
typedef struct list{
int elt ;
struct list* suivant ;
} ;
Les déclarations
-----------------
Un autre exemple d'expression : Un autre exemple d'expression :
.. raw:: latex .. raw:: latex
@ -83,12 +222,6 @@ Un autre exemple d'expression :
\end{algorithmic} \end{algorithmic}
\end{algorithm} \end{algorithm}
On voit qu'une expression peut-être complexe, dans tous les cas une valeur
est renvoyée.
Les déclarations
-----------------
Exemple de déclarations : Exemple de déclarations :
- `a = 1` - `a = 1`
@ -173,8 +306,8 @@ Exemples dans la langue française :
Voir aussi : Voir aussi :
- Déclarations de types primitifs et conversions de type - Les déclarations de types primitifs et conversions de type
- Types de base:: - Les types de base::
Octets (8 bits) byte Octets (8 bits) byte
Entiers courts (16 bits) short Entiers courts (16 bits) short
@ -200,8 +333,8 @@ Il est possible de communiquer de la manière suivante avec un programme :
- lire du texte ou un nombre - lire du texte ou un nombre
- manipuler les prompts - manipuler les prompts
La REPL La REPL (boucle d'interaction)
-------- -------------------------------
.. glossary:: .. glossary::
@ -228,6 +361,7 @@ Le prompt python::
>>> dir() >>> dir()
['__builtins__', '__doc__', '__name__', readline', 'rlcompleter'] ['__builtins__', '__doc__', '__name__', readline', 'rlcompleter']
>>> >>>
Le prompt ipython:: Le prompt ipython::
Python 2.7.12 (default, Nov 19 2016, 06:48:10) Python 2.7.12 (default, Nov 19 2016, 06:48:10)
@ -247,3 +381,9 @@ Le prompt OCaml (utop)::
─( 09:21:24 )─< command 0 >── ─( 09:21:24 )─< command 0 >──
utop # utop #
# let x = 1 in x + 2;;
- : int = 3
# let y = 1 + 2;;
val y : int = 3
# y * y;;
- : int = 9