utilisation de l'extension ifconfig pour les exercices et les corrections
This commit is contained in:
gwen
parent
b37051c78d
commit
5c9ca22877
|
|
@ -269,7 +269,6 @@ Comment rendre un algorithme lisible
|
|||
- Le bon algorithme est structuré.
|
||||
- Le bon algorithme est indenté.
|
||||
|
||||
|
||||
Complexité d'un algorithme
|
||||
--------------------------
|
||||
|
||||
|
|
@ -278,5 +277,10 @@ C'est utile pour pouvoir comparer des algorithmes.
|
|||
|
||||
complexité
|
||||
|
||||
estimer la complexité d'un algorithme,
|
||||
c'est-à-dire estimer le nombre de calculs qu'il utilise.
|
||||
estimer la complexité d'un algorithme, c'est estimer le nombre de calculs qu'il utilise.
|
||||
|
||||
Si f est la fonction caractérisant exactement le coût d’un algorithme et n
|
||||
la taille des données, on s’intéresse à la façon dont augment f(n) lorsque n augmente
|
||||
on va montrer que f(n) n'augmente pas plus vite qu’une autre fonction
|
||||
g(n). Du point de vue mathématique, on dit que la fonction f est dominée
|
||||
asymptotiquement par la fonction g ce qui se note f = O(g)
|
||||
|
|
|
|||
|
|
@ -11,6 +11,10 @@ Première journée : Le langage Python
|
|||
| Recherche d’un mot dans une chaîne de caractères. | On se limite ici à l’algorithme "naïf", en estimant sa complexité. |
|
||||
+------------------------------------------------------+------------------------------------------------------------------------+
|
||||
|
||||
.. ifconfig:: correction
|
||||
|
||||
bla bla bla
|
||||
|
||||
|
||||
Séance 1 : Un apercu des possibles utilisations de Python
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
|
|
|||
|
|
@ -29,9 +29,15 @@ import os
|
|||
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
|
||||
# ones.
|
||||
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.
|
||||
templates_path = ['_templates']
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
@ -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 à
|
||||
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
|
||||
|
||||
|
|
@ -81,13 +82,22 @@ L'instruction de test
|
|||
\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
|
||||
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'à
|
||||
~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
|
|
@ -137,3 +147,20 @@ La boucle tant que (while)
|
|||
\EndWhile
|
||||
\end{algorithmic}
|
||||
\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}
|
||||
|
|
|
|||
|
|
@ -28,6 +28,8 @@ Un langage de programmation doit permettre :
|
|||
Approche historique et chronologique
|
||||
-------------------------------------
|
||||
|
||||
- Lambda calcul (1930)
|
||||
- machines de Turing (1936)
|
||||
- début des langages vers les années 1950 (A0, Fortran(impératif),
|
||||
Lisp(impératif et fonctionnel), Cobol)
|
||||
- années 60 : Simula (classes), CPL (compilation séparée)
|
||||
|
|
|
|||
|
|
@ -1,7 +1,6 @@
|
|||
Introduction à la modularité
|
||||
=============================
|
||||
|
||||
|
||||
Un langage de programmation doit permettre la programmation structurée.
|
||||
|
||||
.. important:: La structuration et l'organisation modulaire sert à maintenir de grands programmes,
|
||||
|
|
|
|||
|
|
@ -45,6 +45,9 @@ Par exemple, la ligne suivante est une expression effectuant une addition::
|
|||
|
||||
5 + 6
|
||||
|
||||
Expressions à partir de types de base
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Autres exemples d'expressions :
|
||||
|
||||
- 5 est une expression de type int
|
||||
|
|
@ -54,6 +57,142 @@ Autres exemples d'expressions :
|
|||
- print ('c') est une expression de type None
|
||||
- raw_input est une expression de type string
|
||||
|
||||
Expressions à partir de types produits
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Les types construits permettent de structurer l’information.
|
||||
|
||||
- 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 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]
|
||||
|
||||
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 :
|
||||
|
||||
.. raw:: latex
|
||||
|
|
@ -83,12 +222,6 @@ Un autre exemple d'expression :
|
|||
\end{algorithmic}
|
||||
\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 :
|
||||
|
||||
- `a = 1`
|
||||
|
|
@ -173,8 +306,8 @@ Exemples dans la langue française :
|
|||
|
||||
Voir aussi :
|
||||
|
||||
- Déclarations de types primitifs et conversions de type
|
||||
- Types de base::
|
||||
- Les déclarations de types primitifs et conversions de type
|
||||
- Les types de base::
|
||||
|
||||
Octets (8 bits) byte
|
||||
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
|
||||
- manipuler les prompts
|
||||
|
||||
La REPL
|
||||
--------
|
||||
La REPL (boucle d'interaction)
|
||||
-------------------------------
|
||||
|
||||
.. glossary::
|
||||
|
||||
|
|
@ -228,6 +361,7 @@ Le prompt python::
|
|||
>>> dir()
|
||||
['__builtins__', '__doc__', '__name__', readline', 'rlcompleter']
|
||||
>>>
|
||||
|
||||
Le prompt ipython::
|
||||
|
||||
Python 2.7.12 (default, Nov 19 2016, 06:48:10)
|
||||
|
|
@ -247,3 +381,9 @@ Le prompt OCaml (utop)::
|
|||
|
||||
─( 09:21:24 )─< command 0 >──
|
||||
utop #
|
||||
# let x = 1 in x + 2;;
|
||||
- : int = 3
|
||||
# let y = 1 + 2;;
|
||||
val y : int = 3
|
||||
# y * y;;
|
||||
- : int = 9
|
||||
|
|
|
|||
Loading…
Reference in New Issue