From 3994cc76ab96aadab624f2e951d0c702bd1b5b4c Mon Sep 17 00:00:00 2001
From: david <david@lipn.fr>
Date: Thu, 10 Sep 2020 12:33:27 +0200
Subject: [PATCH] =?UTF-8?q?tp3=20=C3=A0=20valider?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .gitlab-ci.yml |  5 +++--
 README.md      | 51 +++++++++++++++++++++++++++++---------------------
 2 files changed, 33 insertions(+), 23 deletions(-)

diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index c78fd03..d9abd2c 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -7,9 +7,10 @@ sda:test:
   script:
    - echo "Exercice 1"
    - ls -lF AUTHORS.md
-   - ls -lF plots/*_alpha_bench.pdf
    - echo "Exercice 2"
-   - ls -lF plots/*_alpha_1.5_p_bench.pdf
+   - ls -lF plots/fixed_binary_heap_*_increasing.pdf
+   - ls -lF plots/fixed_binary_heap_*_decreasing.pdf
+   - ls -lF plots/fixed_binary_heap_*_random.pdf
    - echo "Exercice 3"
    - ls -lF RAPPORT.md
    
diff --git a/README.md b/README.md
index 6fdcd76..5e7707e 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# Sujet de TP 2: Benchmarks optimisation
+# Sujet de TP 3: Tas Binaire
 
 ## Règles pour ce semestre
 
@@ -15,42 +15,51 @@ rendre le TP si vous ne finissez pas à temps) via gitlab.
 
 Vos travaux seront évalués une fois à mi-semestre et une fois à la fin du semestre.
 
-## Exercice 1: Optimisation de la structure, en faisant uniquement des ajouts.
+## Exercice 1: Tas binaire borné
 
 Le nom de votre branche est constitué de vos numéros d'étudiants séparés par un _
 
-`git checkout -b tp2_NUMERO1_NUMERO2`
+`git checkout -b tp3_NUMERO1_NUMERO2`
 
 Rajouter le fichier `AUTHORS.md` avec vos noms, prénoms et numéros d'étudiants.
 
-Dans le langage de votre choix, effectuez un benchmark permettant
-d'identifier la valeur de `alpha` qui permet d'otenir le plus petit temps amorti 
-pour l'ajout d'une valeur dans le tableau dynamique.
+Développez une structure/classe de tas binaire dans laquelle le tableau servant
+à stocker les clés est de taille fixe. Cette taille est fixée à la création du tas. Si
+l’utilisateur tente d’ajouter une valeur dans un tas plein, un programme en C
+affichera une erreur et un programme en C++, Python ou Java jettera une exception. La
+structure de tas permettra au moins d’ajouter une clé, et d’extraire la plus petite
+clé contenu dans le tas.
+Pour chaque opération, on veut pouvoir récupérer le nombre d'échanges que la fonction a effectué.
 
-Vous produirez des fichiers pdf sur lequel toutes les courbes de toutes vos experiences
-apparaîtront. Le nom des fichiers terminera par `alpha_bench.pdf`.
 
+## Exercice 2: Benchmark
 
-## Exercice 2: ajout et suppression
+Effectuez des expériences sur l’efficacité en temps et en mémoire de cette structure :
 
-Créer second programme (avec une nouvelle fonction `main` donc), dans lequel vous reproduirez
-l'expérience précédente, avec une modification: au lieu d'ajouter un élément dans la table à chaque itération,
-vous ajouterez l'élément `i` avec une probabilité `p` et vous supprimerez le dernier élément du tableau
-avec une probabilité `1-p`.
+- dans le cas où l’on ne fait qu’ajouter des clés dans l’ordre croissant,
+- dans le cas où l’on ne fait qu’ajouter des clés dans l’ordre décroissant,
+- dans le cas où l’on ne fait qu’ajouter des clés aléatoires.
 
-Dans vos expériences, vous fixerez `alpha` à `1.5` et ferez varier `p`.
-Le nom des fichiers pdf terminera par `alpha_1.5_p_bench.pdf`.
+Inspirez vous des expériences menées sur les tableaux dynamiques. Attention, pour
+chaque expérience, vous devez impérativement écrire de nouvelles fonctions `main`
+dans de nouveaux fichiers et sauvegarder les différents fichiers `pdf` que vous ob-
+tenez grâce à vous expériences. 
 
+Les noms des fichiers pdf seront de la forme `fixed_binary_heap_MESURE_LANGAGE_ORDRE.pdf`
 
-## Exercice 3: Au rapport
+### Exemple:
 
-Commentez le resultat de vos expériences dans un fichier `RAPPORT.md`
+Pour la mesure du temps amorti de l'ajout d'un élément dans l'ordre croissant en `C`,
+le fichier de sortie sera `fixed_binary_heap_amortized_time_C_INCREASING.pdf`
+
+On a donc:
+- MESURE peut valoir \{ amortized_time, wasted_memory, swap \}. 
+- LANGAGE peut valoir \{ C, CPP, Java, Python\}
+- ORDRE peut valoir \{ increasing, descrasing, random\}
 
-1) Dans l'exercice 1, quel est l'alpha le plus efficace en temps? Est-il également le plus efficace 
-en terme de mémoire gaspillée? Quel est le lien entre temps gagné et mémoire gaspillée?
+## Exercice 3: 
 
-2) Dans l'exercice 2, commentez les différents benchmarks quand `p=0.5`, `p < 0.5` et `p > 0.5`
-Tentez d'expliquer ces différents résultats.
+Commentez le resultat de vos expériences dans un fichier `RAPPORT.md`
 
 
 A RENDRE AVANT DIMANCHE!
\ No newline at end of file
-- 
GitLab