diff --git a/src/main/java/fr/univamu/Main.java b/src/main/java/fr/univamu/Main.java
deleted file mode 100644
index 352079d911add55c5496f6a2e9140f0aaa022201..0000000000000000000000000000000000000000
--- a/src/main/java/fr/univamu/Main.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package fr.univamu;
-
-public class Main {
-
-}
\ No newline at end of file
diff --git a/src/main/java/fr/univamu/progav/Main.java b/src/main/java/fr/univamu/progav/Main.java
index 2b25ef7ba6d35c5ac4e1bedcb52e56e89a467d41..314cc54c5ede286a162bf30e323e1b84547b6029 100644
--- a/src/main/java/fr/univamu/progav/Main.java
+++ b/src/main/java/fr/univamu/progav/Main.java
@@ -1,8 +1,10 @@
package fr.univamu.progav;
+import fr.univamu.progav.td2.DebuggerTutorial;
+
public class Main {
public static void main(String[] args) {
-
+ new DebuggerTutorial().exoDebug(); // TD2
}
}
diff --git a/src/main/java/fr/univamu/progav/td2/BackPackSolver.java b/src/main/java/fr/univamu/progav/td2/BackPackSolver.java
new file mode 100644
index 0000000000000000000000000000000000000000..eb8eacf296c4db94d7ec5f0fe0dd0780ec6fdfaf
--- /dev/null
+++ b/src/main/java/fr/univamu/progav/td2/BackPackSolver.java
@@ -0,0 +1,57 @@
+package fr.univamu.progav.td2;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BackPackSolver {
+
+
+
+ private final List<Item> allItems;
+ private final List<Item> currentBackpack = new ArrayList<>();
+ private final int availableVolume;
+
+ public BackPackSolver(List<Item> allItems, int availableVolume) {
+ this.allItems = allItems;
+ this.availableVolume = availableVolume;
+ }
+
+
+ public List<Item> findBestValueBackpack(int nextItemIndex) {
+ if (nextItemIndex >= allItems.size()) {
+ return new ArrayList<>(currentBackpack);
+ }
+ List<Item> backpack1 = findBestValueBackpack(nextItemIndex+1);
+ int currentVolume = sumVolumes(currentBackpack);
+ if (currentVolume + allItems.get(nextItemIndex).volume > availableVolume) {
+ return backpack1;
+ }
+ currentBackpack.add(allItems.get(nextItemIndex));
+ List<Item> backpack2 = findBestValueBackpack(nextItemIndex+1);
+ return selectBestBackpack(backpack1, backpack2);
+ }
+
+
+
+ private List<Item> selectBestBackpack(List<Item> backpack1, List<Item> backpack2) {
+ int value1 = sumValues(backpack1);
+ int value2 = sumValues(backpack2);
+ return (value1 >= value2)? backpack1 : backpack2;
+ }
+
+ public record Item(String name,int volume, int value) {
+ @Override
+ public String toString() {
+ return name + " (Volume=" + volume + ", value=" + value + ")";
+ }
+ }
+
+ private static int sumValues(List<Item> backpack1) {
+ return backpack1.stream().mapToInt(Item::value).sum();
+ }
+
+ private int sumVolumes(List<Item> backpack) {
+ return backpack.stream().mapToInt(Item::volume).sum();
+ }
+
+}
diff --git a/src/main/java/fr/univamu/progav/td2/DebuggerTutorial.java b/src/main/java/fr/univamu/progav/td2/DebuggerTutorial.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2b9af97124f64df461ffce130b2a6b89fb93dd7
--- /dev/null
+++ b/src/main/java/fr/univamu/progav/td2/DebuggerTutorial.java
@@ -0,0 +1,37 @@
+package fr.univamu.progav.td2;
+
+public class DebuggerTutorial {
+
+ private int x = 2;
+ private String text = "an instance variable of a DebuggerTutorial instance";
+
+ public void exoDebug() {
+ double x = 1;
+ f();
+ A a = new A();
+ a.g();
+ for (int i = 0; i < 100000; i++) {
+ String s = "Reprendre l'exécution pour passer la boucle";
+ }
+ String r = "Si vous voyez ceci dans le débugger, c'est GAGNÉ";
+ System.out.println("The end.");
+ }
+
+ public void f() {
+ System.out.println("In method f.");
+ double x = 0;
+ String bad = "Si vous voyez ceci dans le débugger, c'est PERDU.";
+ double y = 0;
+ }
+
+ class A {
+ private final int x = 42;
+
+ public void g() {
+ String bad = "Si vous voyez ceci dans le débugger, c'est PERDU.";
+ System.out.println("In method g.");
+ }
+ }
+
+
+}
diff --git a/src/main/java/fr/univamu/progav/td2/TD2.md b/src/main/java/fr/univamu/progav/td2/TD2.md
index 2e59ad9204820d0990425302b44c86a6181b5ddc..e7e02046ecaa3cd1860782b178c1769f76574dfd 100644
--- a/src/main/java/fr/univamu/progav/td2/TD2.md
+++ b/src/main/java/fr/univamu/progav/td2/TD2.md
@@ -63,14 +63,55 @@ ayant appelé la méthode.
Ces actions permettent d'exécuter le programme pas-à-pas, plus ou moins
finement, en inspectant les valeurs des variables.
+
Exercice 1
==========
+Ce petit exercice vous permet de prendre en main le débugger d'IntelliJ.
+
+- Vérifier que la méthode exécutable `main` de la classe `Main` (fichier `fr.
+univamu.progav.Main.java`) appelle bien la méthode `exoDebug` d'une instance de
+ la classe `DebuggerTutorial` (sinon appeler l'enseignant).
+- Exécuter le programme (tâche gradle run). Le programme doit afficher :
+```
+In method f.
+In method g.
+The end.
+```
+- Placer un *breakpoint* sur la première
+ ligne de la méthode 'main' (comment ? lire ci-dessus). Relancer le programme
+ en mode debug (bouton  en haut
+ à droite). À l'issue de la compilation, vous obtiendrez l'ouverture de la
+ vue du debugger.
+- Inspecter l'objet `this`. Quelles sont ses propriétés et leurs valeurs ?
+ Ceci correspond-il bien au programme écrit ?
+- Avancer l'exécution d'une instruction
+ . Quel est l'effet de
+ l'instruction ?
+- Entrer dans l'exécution de la méthode `f`
+ . Combien la pile
+ a-t-elle de couches ? Quelles sont les valeurs de la variable `x` dans les
+ différentes couches de la pile ?
+- Ressortir de la méthode `f`
+ . Exécuter l'instruction
+ créant une instance de la classe `A` et vérifier son effet sur la mémoire.
+ Quelle est la référence du nouvel objet ?
+- Sauter l'appel de la méthode `g`
+ .
+- Ajouter un breakpoint après la boucle, puis reprendre l'exécution du
+ programme .
+- Continuer jusqu'à voir le message de victoire dans le débugger. Sinon
+ recommencer.
+
+
+Exercice 2
+==========
+
Dans la classe `People`, la méthode `whereIsCharlie` devrait retourner la
position de Charlie, 25 ans, dans la liste. Utiliser le test et le débuggeur
pour trouver l'erreur.
-Exercice 2
+Exercice 3
==========
Dans la classe `ASimpleLoop`, la méthode `nonTerminatingSum` fait un calcul,
@@ -78,7 +119,7 @@ qui ne termine pas. Utiliser le test et le débuggeur, pour comprendre
pourquoi elle ne termine pas. Corriger ensuite la méthode pour que le calcul
s'arrête,
-Exercice 3
+Exercice 4
==========
Dans la classe `Ratio`, représentant les nombres rationnels, l'addition ne
@@ -94,7 +135,7 @@ tester l'égalité des numérateurs et des dénominateurs. Utiliser la méthode
de test et le débuggeur pour trouver l'erreur et la corriger.
-Exercice 4
+Exercice 5
==========
La classe `GuessingGame` reprend la stratégie optimale pour le jeu
diff --git a/src/test/java/fr/univamu/progav/td2/BackPackSolverTest.java b/src/test/java/fr/univamu/progav/td2/BackPackSolverTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d872eeba853abef96ce403ec08d69c917b202dfe
--- /dev/null
+++ b/src/test/java/fr/univamu/progav/td2/BackPackSolverTest.java
@@ -0,0 +1,32 @@
+package fr.univamu.progav.td2;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BackPackSolverTest {
+
+
+ private final static List<BackPackSolver.Item> ITEMS =
+ List.of(
+ new BackPackSolver.Item("Alfa",5,8),
+ new BackPackSolver.Item("Bravo",4,7),
+ new BackPackSolver.Item("Charlie",4,6),
+ new BackPackSolver.Item("Delta",3,4),
+ new BackPackSolver.Item("Echo",2,3)
+ );
+ public static final int AVAILABLE_VOLUME = 10;
+
+ @Test
+ void findBestValueBackpack() {
+ BackPackSolver bp = new BackPackSolver(ITEMS, AVAILABLE_VOLUME);
+ List<BackPackSolver.Item> selection = bp.findBestValueBackpack(0);
+ int totalVolume = selection.stream().mapToInt(BackPackSolver.Item::volume).sum();
+ int totalValue = selection.stream().mapToInt(BackPackSolver.Item::value).sum();
+ assertTrue(totalVolume <= AVAILABLE_VOLUME);
+ assertEquals(16,totalValue);
+ assertEquals(3,selection.size());
+ }
+}
\ No newline at end of file