Ajout exo 1 dans TD2, + sac à dos exemple du cours.

src/main/java/fr/univamu/Main.java

-package fr.univamu;
-
-public class Main {
-
-}
\ No newline at end of file

src/main/java/fr/univamu/progav/Main.java

 package fr.univamu.progav;
 
+import fr.univamu.progav.td2.DebuggerTutorial;
+
 public class Main {
 
   public static void main(String[] args) {
-
+    new DebuggerTutorial().exoDebug(); // TD2
   }
 }

src/main/java/fr/univamu/progav/td2/BackPackSolver.java

+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();
+  }
+
+}

src/main/java/fr/univamu/progav/td2/DebuggerTutorial.java

+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.");
+    }
+  }
+
+
+}

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 ![debug](../../../../../resources/debug.png) 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 
+  ![Passer](../../../../../resources/step-over.png). Quel est l'effet de 
+  l'instruction ? 
+- Entrer dans l'exécution de la méthode `f`
+  ![Entrer](../../../../../resources/step-into.png). 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`
+  ![Sortir](../../../../../resources/step-out.png). 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`
+  ![Passer](../../../../../resources/step-over.png).
+- Ajouter un breakpoint après la boucle, puis reprendre l'exécution du 
+  programme ![Reprendre](../../../../../resources/resume.png).
+- 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 

src/test/java/fr/univamu/progav/td2/BackPackSolverTest.java

+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