controle machine

DEV/DEV3.2/DEV32/1/Bulle.java

@@ -0,0 +1,39 @@
+public class Bulle{
+
+    public static <E> boolean bulle(File<E> pileRemplis, File<E> pileVide){
+        if (pileVide.isEmpty() == false){
+            throw new IllegalArgumentException("Erreur : l'argument pileVide n'est pas vide");
+        }
+
+        E max, v2;
+        boolean haveChangement = false;
+        if (pileRemplis.isEmpty() == false){
+            max = pileRemplis.dequeue();
+            while (pileRemplis.isEmpty() == false){
+                v2 = max;
+                max = pileRemplis.dequeue();
+                if (max < v2){ // changer cette ligne pour rendre les objet comparable
+                    pileVide.enqueue(max);
+                    max = v2;
+                    haveChangement = true;
+                }
+                else{
+                    pileVide.enqueue(v2);
+                }
+            }
+            pileVide.enqueue(max);
+        }
+        return haveChangement;
+    }
+
+    public static <E> File<E> tri(File<E> pile1){
+        File<E> pile2 = new File<>();
+        File<E> transition = null;
+        while (Bulle.bulle(pile1, pile2)){
+            transition = pile2;
+            pile2 = pile1;
+            pile1 = transition; 
+        }
+        return pile2;
+    }
+}

DEV/DEV3.2/DEV32/1/File.java

@@ -0,0 +1,22 @@
+import java.util.*;
+
+public class File<E>{
+
+    private Queue<E> file;
+
+    public File(){
+        this.file = new LinkedList<>();
+    }
+
+    public void enqueue(E valeur){
+        this.file.offer(valeur);
+    }
+
+    public E dequeue(){
+        return this.file.poll();
+    }
+
+    public boolean isEmpty(){
+        return this.file.isEmpty();
+    }
+}

DEV/DEV3.2/DEV32/1/Main.java

@@ -0,0 +1,43 @@
+public class Main{
+    public static void main(String[] args){
+        int[] tableauEntier = new int[args.length];
+        int i;
+        try{
+            //convertion en int
+            for (i=0; i<args.length; i++){
+                tableauEntier[i] = Integer.parseInt(args[i]);
+                if (tableauEntier[i] < 0){
+                    throw new NumberFormatException("Erreur : l'entier naturel saisis est negatif "+tableauEntier[i]);
+                }
+            }
+
+            //remplissage
+            File<Integer> fileRemplisBulle = new File<>();
+            File<Integer> fileRemplisTri = new File<>();
+            File<Integer> fileVide = new File<>();
+            for (int entier : tableauEntier){
+                fileRemplisBulle.enqueue(entier);
+                fileRemplisTri.enqueue(entier);
+            }
+
+            // methode bulle
+            Bulle.bulle(fileRemplisBulle, fileVide);
+            System.out.print("Bulle : ");
+            while (fileVide.isEmpty() == false){
+                System.out.print(fileVide.dequeue() + " ");
+            }
+            System.out.println();
+
+            //methode tri
+            Bulle.tri(fileRemplisTri);
+            System.out.print("Tri : ");
+            while (fileRemplisTri.isEmpty() == false){
+                System.out.print(fileRemplisTri.dequeue() + " ");
+            }
+            System.out.println();
+        }
+        catch(NumberFormatException e){
+            System.out.println("argument invalide");
+        }
+    }
+}

DEV/DEV3.2/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("");
+                   
+        
+    }
+    
+}

DEV/DEV3.2/DEV32/2/MaillonDouble.java

@@ -0,0 +1,30 @@
+public class MaillonDouble <E>{
+
+    private MaillonDouble suivant = null;
+    private MaillonDouble precedent = null;
+    private E valeur;
+
+    public MaillonDouble(E valeur){
+        this.valeur = valeur;
+    }
+
+    public E getValeur(){
+        return this.valeur;
+    }
+
+    public MaillonDouble<E> suivant(){
+        return this.suivant;
+    }
+
+    public MaillonDouble<E> precedent(){
+        return this.precedent;
+    }
+
+    public void setSuivant(MaillonDouble<E> suivant){
+        this.suivant = suivant;
+    }
+
+    public void setPrecedent(MaillonDouble<E> precedent){
+        this.precedent = precedent;
+    }
+}

DEV/DEV3.2/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();
+}

DEV/DEV3.2/DEV32/2/QuestionsTest.txt

@@ -0,0 +1,77 @@
+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]
+
+  ...
+
+  b) Comment fonctionne cette classe?
+  [1 point]
+
+  ...
+
+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
+  => F
+
+  a2) Il est possible de décider si un programme C va s'arrêter quelle que soit son entrée.
+  V/F
+  => F
+
+  a3) Il est possible de décider si un programme python ne va pas s'arrêter pour certaines entrées.
+  V/F
+  => V
+
+  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
+  => V
+
+  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
+  => 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
+  => 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 -cp junit.jar:hamcrest-core.jar org.junit.runner.JUnitCore
+
+ 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? 
+
+ => CLASSPATH=".:/usr/share/java/junit.jar:/usr/share/java/hamcrest-core.jar"
+ java -cp $CLASSPATH org.junit.runner.JUnitCore
+
+
+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.
+

DEV/DEV3.2/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.
+

DEV/DEV3.2/DEV32/2/SimpleDeque.java

@@ -0,0 +1,106 @@
+import javax.sql.rowset.spi.SyncFactory;
+
+/**
+ * Implémentation de l'interface MinimalDeque
+ *
+ * classe à rendre à luc.
+ *
+ * @author vous
+ * @see Java.util.Deque
+ */    
+public class SimpleDeque <E> implements MinimalDeque<E>{
+
+    private MaillonDouble<E> debut;
+    private MaillonDouble<E> fin;
+    
+    public SimpleDeque(){
+    }
+
+    @Override
+    public void addFirst(E e){
+        if (e == null){
+            throw new NullPointerException("argument null");
+        }
+        MaillonDouble<E> premier = new MaillonDouble<>(e);
+        if (this.debut == null){
+            this.debut = premier;
+            this.fin = premier;
+
+        }
+        else{
+            this.debut.setPrecedent(premier);
+            premier.setSuivant(this.debut);
+            this.debut = premier;
+        }
+    }
+
+    @Override
+    public void addLast(E e){
+        if (e == null){
+            throw new NullPointerException("argument null");
+        }
+        MaillonDouble<E> dernier = new MaillonDouble<>(e);
+        if (this.fin == null){
+            this.fin = dernier;
+            this.debut = dernier;
+        }
+        else{
+            this.fin.setSuivant(dernier);
+            dernier.setPrecedent(this.fin);
+            this.fin = dernier;
+        }
+    }
+
+    @Override
+    public boolean isEmpty(){
+        if (this.fin == null && this.debut == null){
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public E removeFirst(){
+        if (this.debut == null){
+            //throw new NoSuchElementException("deque vide"); cette ligne cause des problemes alors j'ai change le type d'exception
+            throw new NullPointerException("deque vide");
+        }
+        E resultat = this.debut.getValeur();
+        this.debut = this.debut.suivant();
+        if (this.debut != null){
+            this.debut.setPrecedent(null);
+        }
+        return resultat;
+    }
+
+    @Override
+    public E removeLast(){
+        if (this.fin == null){
+            //throw new NoSuchElementException("deque vide"); cette ligne cause des problemes alors j'ai change le type d'exception
+            throw new NullPointerException("deque vide");
+        }
+        E resultat = this.fin.getValeur();
+        this.fin = this.fin.precedent();
+        if (this.fin != null){
+            this.fin.setSuivant(null);
+        }
+        return resultat;
+    }
+
+    @Override
+    public String toString(){
+        MaillonDouble<E> maillonActuel = this.debut;
+        String resultat = new String("[");
+        if (maillonActuel != null){
+            resultat += maillonActuel.getValeur();
+            maillonActuel = maillonActuel.suivant();
+        }
+        while (maillonActuel != null){
+            resultat += ", " + maillonActuel.getValeur();
+            maillonActuel = maillonActuel.suivant();
+        }
+        resultat += "]";
+        return resultat;
+    }
+
+}

DEV/DEV3.2/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();
+    }
+}

DEV/DEV3.2/DEV32/2/TestSimpleDeque.java

@@ -0,0 +1,183 @@
+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(expected = NullPointerException.class)
+    public void addFirstNull(){
+	MinimalDeque<String> d = new SimpleDeque<String>();
+	
+        d.addFirst(null);
+    }
+
+    /**
+     * On ne peut pas ajouter avec addLast l'élément null 
+     * [0.5 point]
+     */
+    @Test(expected = NullPointerException.class)
+    public void addLastNull(){
+        MinimalDeque<String> d = new SimpleDeque<String>();
+        d.addLast(null);
+
+    }
+    
+    /**
+     * Un deque sans élément est vide.
+     * [0.5 point]
+     */
+    @Test
+    public void addNoneIsEmpty(){
+        MinimalDeque<String> d = new SimpleDeque<String>();
+        assertTrue(d.isEmpty());
+    }
+    
+    /**
+     * Un deque avec 1 élément n'est pas vide.
+     * [0.5 point]
+     */
+    @Test
+    public void addOneIsNotEmpty(){
+        MinimalDeque<String> d = new SimpleDeque<String>();
+        d.addFirst("meu");
+        assertFalse(d.isEmpty());
+
+    }
+
+    
+    /**
+     * 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";
+    d.addFirst(ga);
+    d.addFirst(bu);
+    d.addFirst(zo);
+    d.addFirst(meu);
+    assertSame(ga,d.removeLast());
+    assertSame(bu,d.removeLast());
+    assertSame(zo,d.removeLast());
+    assertSame(meu,d.removeLast());
+
+    }
+
+    /**
+     * 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(){
+        MinimalDeque<String> d = new SimpleDeque<String>();
+        String ga = "ga";
+        String bu = "bu";
+        String zo = "zo";
+        String meu = "meu";
+        d.addLast(ga);
+        d.addLast(bu);
+        d.addLast(zo);
+        d.addLast(meu);
+        assertSame(ga,d.removeFirst());
+        assertSame(bu,d.removeFirst());
+        assertSame(zo,d.removeFirst());
+        assertSame(meu,d.removeFirst());
+    }
+
+    /**
+     * On ne peut pas enlever d'élément devant d'un deque vide.
+     * [1 point]
+     */
+    @Test(expected = NullPointerException.class)
+    public void removeFirstFromEmpty(){
+        MinimalDeque<String> d = new SimpleDeque<String>();
+        d.removeFirst();
+    }    
+
+    /**
+     * On ne peut pas enlever d'élément derrière d'un deque vide.
+     * [1 point]
+     */
+    @Test(expected = NullPointerException.class)
+    public void removeLastFromEmpty(){
+        MinimalDeque<String> d = new SimpleDeque<String>();
+        d.removeLast();
+    }    
+
+    /**
+     * 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";
+        String ga1, ga2;
+        d.addFirst(ga);
+        ga1 = d.removeFirst();
+        d.addLast(ga);
+        ga2 = d.removeLast();
+        assertSame(ga1,ga2);
+
+    }
+
+
+    /**
+     * 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(900)+100;
+    int i;
+    for (i=0; i<N; i++){
+        int indice = rd.nextInt(3);
+        d.addFirst(s[indice]);
+    }
+    for (i=0; i<N; i++){
+        d.removeLast();
+    }
+    assertTrue(d.isEmpty());
+
+	// rd.nextBoolean())
+
+	
+	// s[rd.nextInt(4)])
+	
+    }
+
+    
+
+    
+}