tp

DEV3.2/ControleMachine/DEV32/1/Bulles.java

@@ -0,0 +1,55 @@
+/**
+ * @author Pourchot Adrian
+ */   
+
+import java.util.*;
+
+public class Bulles{
+
+	public static boolean bulle(ArrayDeque<Integer> listerempli, ArrayDeque<Integer> listevide){
+		int stockentier=listerempli.remove();
+		boolean ordrechanger=false;
+
+
+		while(!listerempli.isEmpty()){
+			if(stockentier>listerempli.element()){
+				listevide.add(listerempli.remove());
+				ordrechanger=true;
+			}
+			else{
+				listevide.add(stockentier);
+				stockentier=listerempli.remove();
+			}
+		}
+		listevide.add(stockentier);
+		return ordrechanger;
+	}
+
+	public static void tri(ArrayDeque<Integer> listeatrier){
+		ArrayDeque<Integer> listeentiervide = new ArrayDeque<Integer>(10);
+		boolean boucle=true;
+
+		while(boucle){
+			boucle=bulle(listeatrier,listeentiervide);
+			while(!listeentiervide.isEmpty()){
+				listeatrier.add(listeentiervide.remove());
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		ArrayDeque<Integer> listeentier = new ArrayDeque<Integer>(10);
+		int affichage;
+
+		for (int i=0; i<args.length; i++) {
+			listeentier.add(Integer.parseInt(args[i]));
+		}
+		tri(listeentier);
+		for (int i=0; i<args.length; i++) {
+			affichage = listeentier.remove();
+			System.out.print(affichage+" ");
+			listeentier.add(affichage);
+		}
+		System.out.println("");
+	}
+}

DEV3.2/ControleMachine/DEV32/2/Exemple.java

@@ -0,0 +1,49 @@
+public class Exemple{
+
+   /**
+     * Exemple d'utilisation de SimpleDequeThatsNotCricket.
+     *
+     * @param args pas de paramètre en ligne de commande prévu.
+     */
+    public static void main(String[] args) {
+
+        MinimalDeque<String> d = new SimpleDequeThatsNotCricket<String>();
+
+        System.out.println(d.toString());//
+        System.out.println("");
+	
+	String s = "Zo";
+	System.out.println("addFirst " + s);//
+	d.addFirst(s);
+	System.out.println(d.toString());//
+	
+	s = "Bu";
+	System.out.println("addFirst " + s);//
+        d.addFirst(s);
+	System.out.println(d.toString());//
+	
+	s = "Ga";
+	System.out.println("addFirst " + s);//
+        d.addFirst(s);
+	System.out.println(d.toString());//
+	
+	s = "Meu";
+	System.out.println("addLast " + s);//
+        d.addLast(s);
+        System.out.println(d.toString());//gab
+        System.out.println("");
+
+        System.out.println("removeFirst "+d.removeFirst()+", reste");
+        System.out.println(d.toString());//Ga
+        System.out.println("removeLast "+d.removeLast()+", reste");
+        System.out.println(d.toString());//Meu
+        System.out.println("removeLast "+d.removeLast()+", reste");
+        System.out.println(d.toString());//Zo
+	System.out.println("removeFirst "+d.removeFirst()+", reste");
+	System.out.println(d.toString());//Bu
+        System.out.println("");
+                   
+        
+    }
+    
+}

DEV3.2/ControleMachine/DEV32/2/MinimalDeque.java

@@ -0,0 +1,68 @@
+/**
+ * interface simplifiée pour un Deque, c'est-à-dire une file d'attente à double extrémité
+ * 
+ * Pour éviter la lourdeur de l'interface Deque de l'API officielle, celle-ci limite 
+ * cette dernière à 5 méthodes essentielles.
+ *
+ * La spécification de ces méthodes est essentiellement identique à celle des méthodes équivalentes 
+ * dans Deque.
+ *
+ * Ici nous choisissons d'interdire null comme élément et de ne pas limiter la capacité de la deque.
+ * Nous ignorons ClassCastException qui n'est a priori pas possible d'obtenir en runtime avec javac sans contorsion.
+ *
+ * The javadoc is reproduced and adapted from source for your convenience below in the file, but in english.
+ *
+ * Il est recommandé d'ajouter un constructeur sans argument qui instancie un deque vide. 
+ * Il est utile de surcharger toString() pour permettre d'afficher utilement la structure de donnée.
+ *Œ
+ * @author Luc Hernandez, Florent Madelaine.
+ * @See  Java.util.Deque
+ */
+
+public interface MinimalDeque<E> {
+
+  /**
+   * Inserts the specified element at the front of this deque if it is
+   * possible to do so.
+   *
+   * @param e the element to add
+   * @throws NullPointerException if the specified element is null
+   * @throws IllegalArgumentException if some property of the specified
+   *         element prevents it from being added to this deque
+   */
+    void addFirst(E e);
+
+    /**
+     * Inserts the specified element at the end of this deque if it is
+     * possible to do so.
+     *
+     * @param e the element to add
+     * @throws NullPointerException if the specified element is null
+     * @throws IllegalArgumentException if some property of the specified
+     *         element prevents it from being added to this deque
+     */
+    void addLast(E e);
+
+    /**
+     * Returns <tt>true</tt> if this collection contains no elements.
+     *
+     * @return <tt>true</tt> if this collection contains no elements
+     */
+    boolean isEmpty();
+
+    /**
+     * Retrieves and removes the first element of this deque.
+     *
+     * @return the head of this deque
+     * @throws NoSuchElementException if this deque is empty
+     */
+    E removeFirst();
+
+    /**
+     * Retrieves and removes the last element of this deque.
+     *
+     * @return the tail of this deque
+     * @throws NoSuchElementException if this deque is empty
+     */
+    E removeLast();
+}

DEV3.2/ControleMachine/DEV32/2/QuestionsTest.txt

@@ -0,0 +1,65 @@
+Ce fichier indiquent les questions à résoudre pour la partie test du TP noté.
+Il faudra soit éditer les squelette de fichiers java fournis, soit répondre dans ce fichier sous la question.
+
+1) [3 points en tout]
+
+   La classe SimpleDequeThatsNotCricket implémente l'interface MinimalDeque demandée.
+   L'expression britannique "that's not cricket" se traduit par "ce n'est pas du jeux".
+   En effet, cette classe fait exactement ce qu'il ne faut pas faire puisqu'elle utilise
+   une implémentation de Deque fournies par java.util.
+
+  a) Quel patron de conception est à l'oeuvre ici?
+  [2 points]
+
+  Il s'agit d'une façade.
+
+  b) Comment fonctionne cette classe?
+  [1 point]
+
+  Elle implémente et redéfinit les méthodes contenu dans l'interfaces MinimalDeque tout en ajoutant de nouvelles méthodes propre à elle même.
+
+2) [-6 à 4 points en tout]
+
+   Indiquez pour chaque assertion si elles est vraie ou non.
+
+   [2 points par groupe d'assertion si toutes correctes,
+     -1 si une faute par question,
+     0 si pas répondu)]
+
+  a1) Il est possible de décider si un programme java va s'arrêter quelle que soit son entrée.
+  V/F
+  a2) Il est possible de décider si un programme C va s'arrêter quelle que soit son entrée.
+  V/F
+  a3) Il est possible de décider si un programme python ne va pas s'arrêter pour certaines entrées.
+  V/F
+
+  b1) Il est possible de décrire les propriétés souhaitées d'un programme en utilisant
+      des langages de spécifications inspirés de la logique du premier ordre.
+  V/F
+  b2) Il existe des logiciels qui étant donné une spécification et un programme peuvent
+      décider à coup sûr que le programme satisfait la spécification ou pas.
+  V/F
+  b3) Il existe des logiciels qui étant donné une spécification et un programme peuvent
+      décider si le programme satisfait la spécification ou pas en demandant
+      à un logiciel d'IA générative (comme chatGPT) pour générer une preuve.
+  V/F
+
+3) [1 point en tout]
+
+ a) Quelle est la commande pour lancer les tests de la classe TestSimpleDeque si les archives
+ junit.jar et hamcrest-core.jar sont dans le même répertoire?
+
+ java junit.jar hamcrest-core.jar TestSimpleDeque
+
+ b) Quelle est la commande pour lancer les tests de la classe TestSimpleDeque si les archives
+ junit.jar et hamcrest-core.jar sont dans le CLASSPATH? 
+
+ java org.junit.runner.JUnitCore TestSimpleDeque
+
+4) [12 points en tout]
+
+   Remplissez les tests dans TestSimpleDeque.java
+   
+   Il faut absolument que ce fichier compile sinon c'est 0 pour cette partie.
+   voir barème dans TestSimpleDeque pour chaque test.
+

DEV3.2/ControleMachine/DEV32/2/README.txt

@@ -0,0 +1,20 @@
+Contenu du répertoire.
+
+README.txt			ce fichier.
+838_planche06_copie.webp	vive les shadocks
+
+MinimalDeque.java		interface minimale d'un deque
+SimpleDequeThatsNotCricket.java implémentation qui triche
+Exemple.java			exemple d'usage
+
+
+SimpleDeque.java		fichier à rendre pour Luc
+
+QuestionsTest.txt		Fichier à remplir pour Florent
+TestSimpleDeque.java		Fichier à remplir pour Florent
+
+
+Pour utiliser JUnit :
+
+Attention à vérifier votre CLASSPATH qui doit contenir le jar pour junit4 et potentiellement celui de hamcrest si vous souhaitez utiliser des mécanismes d'assertions plus avancés.
+

DEV3.2/ControleMachine/DEV32/2/SimpleDeque.java

@@ -0,0 +1,45 @@
+/**
+ * Implémentation de l'interface MinimalDeque
+ *
+ * classe à rendre à luc.
+ *
+ * @author Pourchot Adrian
+ * @see Java.util.Deque
+ */    
+public class SimpleDeque<E> implements MinimalDeque{
+
+	private E[] deque;
+    
+    public SimpleDeque(){
+		this.deque = new E[0];
+    }
+    
+    public void addFirst(E e){
+		Objects.requireNonNull(e, "e must not be null");
+
+    }
+    
+    public void addLast(E e){
+		Objects.requireNonNull(e, "e must not be null");
+		this.deque = this.deque.copyOf(this.deque, this.deque.length+1);
+		this.deque[this.deque.length-1] = e;
+    }
+    
+    public boolean isEmpty(){
+		if (this.deque.length==0){
+			return true;
+		}
+		else{
+			return false;
+		}
+    }
+    
+    public E removeFirst(){
+		this.deque = this.deque.copyOfRange(this.deque, 1, this.deque.length);
+    }
+    
+    public E removeLast(){
+		this.deque = this.deque.copyOfRange(this.deque, 0, this.deque.length-1);
+    }
+
+}

DEV3.2/ControleMachine/DEV32/2/SimpleDequeThatsNotCricket.java

@@ -0,0 +1,52 @@
+import java.util.Objects;
+import java.util.LinkedList;
+import java.util.Deque;
+
+
+/**
+ * Implémentation de l'interface MinimalDeque
+ *
+ * sert uniquement à tester les tests
+ * contrairement au sujet de Luc "Huck" Hernandez, fonctionne par délégation à un attribut
+ * implémentant Deque (ici une LinkedList)
+ *
+ * @author Florent Madelaine
+ * @see Java.util.Deque
+ */    
+public class SimpleDequeThatsNotCricket<E> implements MinimalDeque<E>{
+
+    /**
+     * attribut à qui on va déléguer le travail.
+     */
+    private Deque<E> d;
+    
+    public SimpleDequeThatsNotCricket(){
+	this.d = new LinkedList<E>();
+    }
+    
+    public void addFirst(E e){
+	Objects.requireNonNull(e, "e must not be null");
+	this.d.addFirst(e);
+    }
+    
+    public void addLast(E e){
+	Objects.requireNonNull(e, "e must not be null");
+	this.d.addLast(e);
+    }
+    
+    public boolean isEmpty(){
+	return this.d.isEmpty();
+    }
+    
+    public E removeFirst(){
+	return this.d.removeFirst();
+    }
+    
+    public E removeLast(){
+	return this.d.removeLast();
+    }
+
+    public String toString(){
+	return this.d.toString();
+    }
+}

DEV3.2/ControleMachine/DEV32/2/TestSimpleDeque.java

@@ -0,0 +1,141 @@
+import static org.junit.Assert.assertTrue; // import static : une facilité offerte depuis java5 (pas besoin de mettre le préfixe)
+import static org.junit.Assert.assertFalse; //
+import static org.junit.Assert.assertSame; //
+import org.junit.Test;
+
+
+import java.util.NoSuchElementException;
+import java.util.Random;
+
+
+/**
+ * Une classe pour faire des tests sur la classe SimpleDeque avec JUnit
+ * On utlise des string comme type paramétré.
+ */
+public class TestSimpleDeque {
+
+
+    /**
+     * On ne peut pas ajouter avec addFirst l'élément null 
+     * [0.5 point]
+     */
+    @Test
+    public void addFirstNull(){
+	MinimalDeque<String> d = new SimpleDeque<String>();
+	
+        d.addFirst(null);
+        d.contains(null);
+    }
+
+    /**
+     * On ne peut pas ajouter avec addLast l'élément null 
+     * [0.5 point]
+     */
+    @Test
+    public void addLastNull(){
+
+    }
+    
+    /**
+     * Un deque sans élément est vide.
+     * [0.5 point]
+     */
+    @Test
+    public void addNoneIsEmpty(){
+
+    }
+    
+    /**
+     * Un deque avec 1 élément n'est pas vide.
+     * [0.5 point]
+     */
+    @Test
+    public void addOneIsNotEmpty(){
+
+    }
+
+    
+    /**
+     * Dans un deque vide ajouter devant "ga" "bu" "zo" "meu" devant puis enlever à la fin me redonne les mêmes string (identiques aux précédents) et dans le même ordre. 
+     * [1 point]
+     */
+    @Test
+    public void pasDeResquilleur(){
+	MinimalDeque<String> d = new SimpleDeque<String>();
+	String ga = "ga";
+	String bu = "bu";
+	String zo = "zo";
+	String meu = "meu";
+
+    }
+
+    /**
+     * Dans un deque vide ajouter "ga" "bu" "zo" "meu" derrière puis enlever au débutr me redonne les mêmes string (identiques aux précédents) et dans le même ordre. 
+     * [1 point]
+     */
+    @Test
+    public void pasDeResquilleurQuantique(){
+
+    }
+
+    /**
+     * On ne peut pas enlever d'élément devant d'un deque vide.
+     * [1 point]
+     */
+    @Test
+    public void removeFirstFromEmpty(){
+
+    }    
+
+    /**
+     * On ne peut pas enlever d'élément derrière d'un deque vide.
+     * [1 point]
+     */
+    @Test
+    public void removeLastFromEmpty(){
+
+    }    
+
+    /**
+     * Dans un deque vide ajouter "ga" puis enlever me redonne le même string que ajouter ou enlever soit devant oui derrière. 
+     * [2 point]
+     */
+    @Test
+    public void mangerLaBananeParLesDeuxBouts(){
+	MinimalDeque<String> d = new SimpleDeque<String>();
+	String ga = "ga";
+
+    }
+
+
+    /**
+     * Invariant de taille
+     * Lancer un nombre entier aléatoire N compris entre 100 et 1000 (inclus).
+     *
+     * Ajouter au hasard, devant ou derrière N éléments tirés au hasard dans {"Ga", "bu", "zo", "meu"}.
+     *
+     * Enlever au hasard, devant ou derrière N éléments.
+     *
+     * Vérifier finalement que la Deque est vide.
+     *
+     * [4 point]
+     */
+    @Test
+    public void invariantTaille(){
+	MinimalDeque<String> d = new SimpleDeque<String>();
+	String[] s = {"ga","bu","zo","meu"};
+	Random rd = new Random();
+
+	int N = rd.nextInt(42)+4;
+
+	// rd.nextBoolean())
+
+	
+	// s[rd.nextInt(4)])
+	
+    }
+
+    
+
+    
+}