ajout td3

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

@@ -28,6 +28,7 @@ public class BackPackSolver {
     }
     currentBackpack.add(allItems.get(nextItemIndex));
     List<Item> backpack2 = findBestValueBackpack(nextItemIndex+1);
+    currentBackpack.removeLast();
     return selectBestBackpack(backpack1, backpack2);
   }
 

src/main/java/fr/univamu/progav/td2/TD2.md

@@ -79,7 +79,8 @@ 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 
+  ligne de la méthode `exoDebug` (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.

src/main/java/fr/univamu/progav/td3/ExoArray.java

+package fr.univamu.progav.td3;
+
+public class ExoArray {
+
+  /** Initialise un tableau d'entiers, la cellule d'indice \(i\) contient l'entier \(i\), sauf une
+   * cellule sur trois depuis l'indice 1, qui contiennent \(-i\). Ainsi le tableau commence par
+   * <code>{0,-1,2,3,-4,5,6,-7,...}</code>.
+   * @param size la longueur souhaitée du tableau
+   * @return le tableau d'entiers
+   */
+  public static int[] initArray(int size) {
+    // TODO
+    return null;
+  }
+
+  /** Calcule la somme des entiers en position paire dans un tableau.
+   * Par exemple pour <code>{1,3,2,4}</code> le résultat est \(3 = 1 + 2\).
+   * @param array le tableau dont on somme les entiers en position paire.
+   * @return la somme des entiers en position paire.
+   */
+  public static int sumEvenPositions(int[] array) {
+    // TODO
+    return 0;
+  }
+
+  /** Décale tous les éléments du tableau "vers la gauche", sauf l'élément d'indice 0 qui est
+   * replacé en fin de tableau. Par exemple pour <code>{1,4,2,3}</code>, le tableau devient
+   * <code>{4,2,3,1}</code>.
+   * @param array le tableau à modifier.
+   */
+  public static void shiftToLeft(int[] array) {
+    // TODO
+  }
+}

src/main/java/fr/univamu/progav/td3/ExoList.java

+package fr.univamu.progav.td3;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ExoList {
+
+  /** Initialise une liste d'entiers consécutifs depuis 0, par exemple <code>0,1,2,3,4</code>.
+   * @param size la longueur souhaitée de la liste.
+   * @return la liste ainsi initialisée.
+   */
+  public static List<Integer> initList(int size) {
+    // TODO
+    return null;
+  }
+
+  /** Ajoute 1 à chaque entier d'une liste.
+   * @param values la liste des entiers à incrémenter.
+   */
+  public static void addOneEverywhere(List<Integer> values) {
+    // TODO
+  }
+
+  /** Duplique chaque élément de la liste, en fin de liste, par exemple la liste <code>1,2,
+   * 3</code> devient <code>1,2,3,1,2,3</code>.
+   * @param values la liste à dupliquer.
+   */
+  public static void duplicate(List<Integer> values) {
+    // TODO
+  }
+}

src/main/java/fr/univamu/progav/td3/ExoMap.java

+package fr.univamu.progav.td3;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Une classe permettant de compter dans un texte, pour chaque mot, combien de fois il apparait.
+ */
+public class ExoMap {
+
+  // TODO initialisation à une table d'association vide
+  private final Map<String,Integer> counters = null;
+
+  /** Augmente le compte d'un mot.
+   * @param word le mot à compter.
+   */
+  public void count(String word) {
+    // TODO
+  }
+
+  /** Compte tous les mots d'une liste.
+   * @param words une liste de mots à compter.
+   */
+  public void count(List<String> words) {
+    // TODO
+  }
+
+  /** Retourne le nombre d'occurences comptées d'un mot.
+   * @param word un mot.
+   * @return le nombre d'occurences de ce mot.
+   */
+  public int countOf(String word) {
+    // TODO
+    return 0;
+  }
+
+}
+
+
+

src/main/java/fr/univamu/progav/td3/ExoQueue.java

+package fr.univamu.progav.td3;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+
+/**
+ *  Une classe permettant d'évaluer des expressions arithmétiques entières en notation polonaise
+ *  inverse, comme <em>3 5 2 * 1 + -4 7 + + *</em>. L'évaluation d'une telle expression se fait à
+ *  l'aide d'une pile, et en lisant l'expression de gauche à droite :
+ *  <ul>
+ *    <li>3 : on empile 3, la pile est \([3]\)</li>
+ *    <li>5 : on empile 5, la pile est \([3,5]\)</li>
+ *    <li>2 : on empile 2, la pile est \([3,5,2]\)</li>
+ *    <li>* : on remplace les deux éléments supérieurs par leur produit, la pile est \([3,10]\) </li>
+ *    <li>1 : on empile 1, la pile est  \([3,10,1]\)</li>
+ *    <li>+ : on remplace les deux éléments supérieurs par leur somme, la pile est  \([3,11]\)</li>
+ *    <li>-4 : on empile -4, la pile est  \([3,11,-4]\)</li>
+ *    <li>7 : on empile 7, la pile est  \([3,11,-4,7]\)</li>
+ *    <li>+ : on remplace les deux éléments supérieurs par leur somme, la pile est  \([3,11,3]\) </li>
+ *    <li>+ : on remplace les deux éléments supérieurs par leur somme, la pile est  \([3,14]\)</li>
+ *    <li>* : on remplace les deux éléments supérieurs par leur produit, la pile est \([42]\)
+ *    </li>
+ *  </ul>
+ *  Un des avantages de cette notation est l'absence de parenthèses, qui sont inutiles.
+ */
+public class ExoQueue {
+
+  // TODO initialisée avec une pile vide
+  private final Deque<Integer> intStack =null;
+
+
+  /** Insère une valeur en haut de la pile.
+   * @param value la valeur à insérer.
+   */
+  public void addValue(int value) {
+    // TODO
+    intStack.offerLast(value);
+  }
+
+  /**
+   * Réalise l'addition des deux premiers éléments de la pile.
+   */
+  public void performAddition() {
+    //TODO
+  }
+
+  /**
+   * Réalise la multiplication des deux premiers éléments de la pile.
+   */
+  public void performMultiplication() {
+    // TODO
+  }
+
+  /**
+   * @return le nombre de valeurs dans la pile
+   */
+  public int nbRemainingValues() {
+    // TODO
+    return 0;
+  }
+
+  /**
+   * @return la valeur en haut de la pile (<code>null</code> si la pile est vide)
+   */
+  public int topValue() {
+    // TODO
+    return 0;
+  }
+
+}

src/main/java/fr/univamu/progav/td3/ExoSet.java

+package fr.univamu.progav.td3;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class ExoSet {
+
+  /** Construit l'ensemble des éléments d'une liste (les éléments redondants disparaissent).
+   * @param list la liste des éléments qui seront dans l'ensemble.
+   * @return l'ensemble ainsi construit.
+   */
+  public static Set<Integer> fromList(List<Integer> list) {
+    // TODO
+    return null;
+  }
+
+  /** Construit la liste des éléments de l'union de deux ensembles. Chaque élément doit
+   * apparaître au plus une fois.
+   * @param set1 le premier ensemble.
+   * @param set2 le deuxième ensemble.
+   * @return une liste union des deux ensembles.
+   */
+  public static List<Integer> unionToList(Set<Integer> set1, Set<Integer> set2) {
+    // TODO
+    return null;
+  }
+
+}

src/main/java/fr/univamu/progav/td3/TD3.md

+Exercice 1
+==========
+
+Un tableau est une structure indicée de taille fixe, contenant des valeurs 
+d'un même type.
+
+Compléter les méthodes de la classe `ExoArray`, jusqu'à validation des tests.
+
+Exercice 2
+==========
+
+Une liste est une collection indicée de taille variable, contenant des 
+valeurs d'un même type.
+
+Compléter les méthodes de la classe `ExoList`, jusqu'à validation des tests.
+
+Exercice 3
+==========
+
+Une file est une collection de valeurs de même type, organisées en séquences,
+avec des opérations d'insertion et de suppression à ses extrémités.
+
+Compléter les méthodes de la classe `ExoQueue`, jusqu'à validation des tests.
+Cette classe permet l'évaluation d'expressions arithmétiques en notation 
+polonaise inversée.
+
+Exercice 4
+==========
+
+Un ensemble est une collection de valeur d'un même type, chaque valeur y est 
+unique, et optimisée pour réaliser les opération d'insertion, suppression et 
+test d'appartenance. 
+
+Compléter les méthodes de la classe `ExoSet`, jusqu'à validation des tests.
+
+Exercice 5
+==========
+
+Une table d'association est une collection de clés d'un même type, chaque 
+clé étant unique, et associant à chaque clé une valeur. Toutes les valeurs 
+sont du même type. Une table d'association est optimisée pour 
+insérer ou supprimer efficacement les clés, et récupérer ou modifier la 
+valeur associée d'une clé.
+
+Compléter les méthodes de la classe `ExoMap`, jusqu'à validation des tests.
+Cette classe permet de compter le nombre d'occurrences de chaque mot dans une 
+liste de mots.
+
+
+

src/test/java/fr/univamu/progav/td3/ExoArrayTest.java

+package fr.univamu.progav.td3;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ExoArrayTest {
+
+  @Test
+  void initArray() {
+    int[] a4 = ExoArray.initArray(4);
+    assertArrayEquals(new int[]{0,-1,2,3}, a4);
+    int[] a10 = ExoArray.initArray(10);
+    assertArrayEquals(new int[]{0,-1,2,3,-4,5,6,-7,8,9}, a10);
+    int[] a0 = ExoArray.initArray(0);
+    assertEquals(0, a0.length);
+    int[] a10000 = ExoArray.initArray(10000);
+    assertEquals(10000, a10000.length);
+  }
+
+  @Test
+  void sumEvenPositions() {
+    int[] a1 = {0,1,2,3,4,5,6};
+    assertEquals(12, ExoArray.sumEvenPositions(a1));
+    int[] a2 = {0,1,2,3,4,5,6,7};
+    assertEquals(12, ExoArray.sumEvenPositions(a2));
+    int[] a3 = {5,3,7,-2,-4,-8,1,-2,8,-3,3,10};
+    assertEquals(20, ExoArray.sumEvenPositions(a3));
+  }
+
+  @Test
+  void shiftToLeft() {
+    int[] a1 =  {1,2,3,4,5};
+    ExoArray.shiftToLeft(a1);
+    assertArrayEquals(new int[] {2,3,4,5,1}, a1);
+    int[] a2 = {1,2};
+    ExoArray.shiftToLeft(a2);
+    assertArrayEquals(new int[] {2,1},a2);
+    int[] a3 = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
+    ExoArray.shiftToLeft(a3);
+    assertArrayEquals(new int[] {8,7,6,5,4,3,2,1,0,9}, a3);
+    int[] a4 = {};
+    ExoArray.shiftToLeft(a4);
+    assertArrayEquals(new int[]{}, a4);
+
+  }
+}
\ No newline at end of file

src/test/java/fr/univamu/progav/td3/ExoListTest.java

+package fr.univamu.progav.td3;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+class ExoListTest {
+
+  @Test
+  void initList() {
+    assertEquals(List.of(0,1,2,3,4), ExoList.initList(5));
+    assertEquals(List.of(0,1,2,3,4,5,6,7,8,9), ExoList.initList(10));
+    assertEquals(List.of(), ExoList.initList(0));
+    List<Integer> l1000 = ExoList.initList(1000);
+    assertEquals(1000, l1000.size());
+    assertEquals(532, l1000.get(532));
+    assertEquals(763, l1000.get(763));
+    assertEquals(923, l1000.get(923));
+  }
+
+  @Test
+  void addOneEverywhere() {
+    List<Integer> l1 = new ArrayList<>(List.of(0,1,2,3,4));
+    ExoList.addOneEverywhere(l1);
+    assertEquals(List.of(1,2,3,4,5), l1);
+    List<Integer> l2 = new ArrayList<>(List.of(9,-1,3,6,-4));
+    ExoList.addOneEverywhere(l2);
+    assertEquals(List.of(10,0,4,7,-3), l2);
+    List<Integer> l3 = new ArrayList<>();
+    ExoList.addOneEverywhere(l3);
+    assertEquals(List.of(), l3);
+  }
+
+  @Test
+  void duplicate() {
+    List<Integer> l1 = new ArrayList<>(List.of(0,1,2,3,4));
+    ExoList.duplicate(l1);
+    assertEquals(List.of(0,1,2,3,4,0,1,2,3,4), l1);
+    List<Integer> l2 = new ArrayList<>(List.of(0,1));
+    ExoList.duplicate(l2);
+    assertEquals(List.of(0,1,0,1), l2);
+    List<Integer> l3 = new ArrayList<>();
+    ExoList.duplicate(l3);
+    assertEquals(List.of(), l3);
+  }
+}
\ No newline at end of file

src/test/java/fr/univamu/progav/td3/ExoMapTest.java

+package fr.univamu.progav.td3;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ExoMapTest {
+
+  @Test
+  void test1() {
+    List<String> words = List.of("alfa", "bravo", "charlie", "alfa", "charlie", "delta");
+    ExoMap counter = new ExoMap();
+    counter.count(words);
+    assertEquals(2,counter.countOf("alfa"));
+    assertEquals(1,counter.countOf("bravo"));
+    assertEquals(2,counter.countOf("charlie"));
+    assertEquals(1,counter.countOf("delta"));
+    assertEquals(0,counter.countOf("echo"));
+    counter.count("delta");
+    assertEquals(2,counter.countOf("alfa"));
+    assertEquals(1,counter.countOf("bravo"));
+    assertEquals(2,counter.countOf("charlie"));
+    assertEquals(2,counter.countOf("delta"));
+    assertEquals(0,counter.countOf("echo"));
+  }
+
+  void test2() {
+    List<String> words = List.of("alfa", "alfa", "bravo", "charlie", "bravo", "alfa", "charlie", "delta", "echo", "echo", "echo", "echo");
+    ExoMap counter = new ExoMap();
+    counter.count(words);
+    assertEquals(3,counter.countOf("alfa"));
+    assertEquals(2,counter.countOf("bravo"));
+    assertEquals(2,counter.countOf("charlie"));
+    assertEquals(1,counter.countOf("delta"));
+    assertEquals(4,counter.countOf("echo"));
+  }
+
+  void testEmpty() {
+    ExoMap counter = new ExoMap();
+    counter.count(List.of());
+    assertEquals(0,counter.countOf("alfa"));
+    assertEquals(0,counter.countOf("bravo"));
+    assertEquals(0,counter.countOf("charlie"));
+  }
+}
\ No newline at end of file

src/test/java/fr/univamu/progav/td3/ExoQueueTest.java

+package fr.univamu.progav.td3;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ExoQueueTest {
+
+  @Test
+  void unit() {
+    ExoQueue q = new ExoQueue();
+    q.addValue(8);
+    assertEquals(1,q.nbRemainingValues());
+    assertEquals(8,q.topValue());
+  }
+
+  @Test
+  void addition() {
+    ExoQueue q = new ExoQueue();
+    q.addValue(3);
+    q.addValue(5);
+    assertEquals(2, q.nbRemainingValues());
+    q.performAddition();
+    assertEquals(1, q.nbRemainingValues());
+    assertEquals(8,q.topValue());
+  }
+
+  @Test
+  void multiplication() {
+    ExoQueue q = new ExoQueue();
+    q.addValue(3);
+    q.addValue(5);
+    q.addValue(2);
+    assertEquals(3, q.nbRemainingValues());
+    q.performMultiplication();
+    assertEquals(2, q.nbRemainingValues());
+    assertEquals(10,q.topValue());
+    q.performMultiplication();
+    assertEquals(1, q.nbRemainingValues());
+    assertEquals(30,q.topValue());
+  }
+
+
+  // evaluate 3 5 2 x 1 + -4 7 + + *
+  @Test
+  void sequence() {
+    ExoQueue q = new ExoQueue();
+    q.addValue(3);
+    q.addValue(5);
+    q.addValue(2);
+    q.performMultiplication();
+    q.addValue(1);
+    q.performAddition();
+    q.addValue(-4);
+    q.addValue(7);
+    q.performAddition();
+    q.performAddition();
+    q.performMultiplication();
+    assertEquals(1,q.nbRemainingValues());
+    assertEquals(42,q.topValue());
+  }
+
+}
\ No newline at end of file

src/test/java/fr/univamu/progav/td3/ExoSetTest.java

+package fr.univamu.progav.td3;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ExoSetTest {
+
+  @Test
+  void fromList() {
+    List<Integer> l1 = List.of(1,2,3,4);
+    Set<Integer> set = ExoSet.fromList(l1);
+    for (int i : l1) {
+      assertTrue(set.contains(i));
+    }
+    assertEquals(4, set.size());
+    List<Integer> l2 = List.of(1,2,3,1,3,2,1,3,4,2,3,1,5,4,2);
+    Set<Integer> set2 = ExoSet.fromList(l2);
+    for (int i : l2) {
+      assertTrue(set2.contains(i));
+    }
+    assertEquals(5, set2.size());
+    Set<Integer> set3 = ExoSet.fromList(List.of());
+    assertTrue(set3.isEmpty());
+  }
+
+  @Test
+  void unionToList() {
+    Set<Integer> set1 = Set.of(1,2,4,6);
+    Set<Integer> set2 = Set.of(1,3,4,5);
+    List<Integer> list = ExoSet.unionToList(set1, set2);
+    for (int i : list) {
+      assertTrue(set1.contains(i) || set2.contains(i));
+    }
+    for (int i : set1) {
+      assertTrue(list.contains(i));
+    }
+    for (int i : set2) {
+      assertTrue(list.contains(i));
+    }
+    assertEquals(6, list.size());
+  }
+}
\ No newline at end of file