ajout crypto

DEV3.2/DEV32/Division.java

@@ -0,0 +1,41 @@
+/*Felix-vimalaratnam
+Patrick*/
+
+public class Division {
+
+	public static boolean IsInt(String c){
+		try{
+			int a = Integer.parseInt(c);
+		}catch(Exception e){
+			return Boolean.FALSE;
+		}
+		return Boolean.TRUE;
+	}
+
+	public static String toString(FileTableau f){
+		String ligne = "";
+		while(f.taille() != 0){
+			ligne = ligne + " " + f.retirer().toString();
+		} 
+		return ligne;
+	}
+
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            System.out.println("Veuillez fournir une expression en notation polonaise inversée.");
+            return;
+        }
+        FileTableau<Integer> ligne1 = new FileTableau<>();
+        FileTableau<String> ligne2 = new FileTableau<>();
+        for (int i = 0; i < args.length; i++){
+        	if (IsInt(args[i])){
+        		ligne1.ajouter(Integer.parseInt(args[i]));
+        	}
+        	else{
+        		ligne2.ajouter(args[i]);
+        	}
+        }
+        System.out.println(toString(ligne1));
+        System.out.println(toString(ligne2));
+    }
+}

DEV3.2/DEV32/Division2.java

@@ -0,0 +1,50 @@
+/*Felix-vimalaratnam
+Patrick*/
+
+public class Division2 {
+
+	public static boolean IsInt(String c){
+		try{
+			int a = Integer.parseInt(c);
+		}catch(Exception e){
+			return Boolean.FALSE;
+		}
+		return Boolean.TRUE;
+	}
+
+	public static String toString(FileTableau2 f){
+		String ligne = "";
+		while(f.taille() != 0){
+			ligne = ligne + " " + f.retirer().toString();
+		} 
+		return ligne;
+	}
+
+	public static String toStringpourString(FileTableau2 f){
+		String ligne = "";
+		while(f.taille() != 0){
+			f.removeif();
+			ligne = ligne + " " + f.retirer().toString();
+		} 
+		return ligne;
+	}
+
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            System.out.println("Veuillez fournir une expression en notation polonaise inversée.");
+            return;
+        }
+        FileTableau2<Integer> ligne1 = new FileTableau2<>();
+        FileTableau2<String> ligne2 = new FileTableau2<>();
+        for (int i = 0; i < args.length; i++){
+        	if (IsInt(args[i])){
+        		ligne1.ajouter(Integer.parseInt(args[i]));
+        	}
+        	else{
+        		ligne2.ajouter(args[i]);
+        	}
+        }
+        System.out.println(toString(ligne1));
+        System.out.println(toStringpourString(ligne2));
+    }
+}

DEV3.2/DEV32/Ensemble.java

@@ -0,0 +1,21 @@
+/*Felix-vimalaratnam
+Patrick*/
+
+/**
+ * Une structure de données abstraite qui contient des entiers entre 0 et 100. Aucune
+ * valeur ne peut apparaître plusieurs fois dans cette structure.
+ * 
+ * @version 1.0 15 January 2025
+ * @author Luc Hernandez
+ */
+public interface Ensemble {
+  /**
+   * Ajoute une nouvelle valeur à la structure.
+   * 
+   * @param element la nouvelle valeur
+   * @return true si la nouvelle valeur a été ajoutée, false si elle était déjà présente
+   * @throws IllegalArgumentException si l'argument n'est pas compris entre 0 et 100
+   */
+  public boolean ajouter(byte element);
+  public boolean comparer(byte element);
+}

DEV3.2/DEV32/File.java

@@ -0,0 +1,9 @@
+/*Felix-vimalaratnam
+Patrick*/
+
+public interface File<E> {
+    void ajouter(E element);    // Ajoute un élément en fin de la file
+    E retirer();                // Retire et retourne l'élément en tête de la file
+    int taille();               // Retourne la taille de la file
+    boolean estVide();          // Vérifie si la file est vide
+}

DEV3.2/DEV32/File2.java

@@ -0,0 +1,10 @@
+/*Felix-vimalaratnam
+Patrick*/
+
+public interface File2<E> {
+    void ajouter(E element);    // Ajoute un élément en fin de la file
+    E retirer();                // Retire et retourne l'élément en tête de la file
+    void removeif();            //retire si il a un tiret
+    int taille();               // Retourne la taille de la file
+    boolean estVide();          // Vérifie si la file est vide
+}

DEV3.2/DEV32/FileTableau.java

@@ -0,0 +1,44 @@
+/*Felix-vimalaratnam
+Patrick*/
+
+public class FileTableau<E> implements File<E> {
+    private static final int CAPACITE_INITIALE = 20;
+    private E[] elements;
+    private int taille = 0;
+    private int debut = 0;
+    private int fin = 0;
+
+    @SuppressWarnings("unchecked")
+    public FileTableau() {
+        elements = (E[]) new Object[CAPACITE_INITIALE]; // Création du tableau initial
+    }
+
+    @Override
+    public void ajouter(E element) {
+        elements[fin] = element;
+        fin = (fin + 1);
+        taille++;
+    }
+
+    @Override
+    public E retirer() {
+        if (estVide()) {
+            throw new IllegalStateException("La file est vide");
+        }
+        E element = elements[debut];
+        elements[debut] = null; // Supprime la référence pour éviter les fuites de mémoire
+        debut = (debut + 1);
+        taille--;
+        return element;
+    }
+
+    @Override
+    public int taille() {
+        return taille;
+    }
+
+    @Override
+    public boolean estVide() {
+        return taille == 0;
+    }
+}

DEV3.2/DEV32/FileTableau2.java

@@ -0,0 +1,54 @@
+/*Felix-vimalaratnam
+Patrick*/
+
+public class FileTableau2<E> implements File2<E> {
+    private static final int CAPACITE_INITIALE = 20;
+    private E[] elements;
+    private int taille = 0;
+    private int debut = 0;
+    private int fin = 0;
+
+    @SuppressWarnings("unchecked")
+    public FileTableau2() {
+        elements = (E[]) new Object[CAPACITE_INITIALE]; // Création du tableau initial
+    }
+
+    @Override
+    public void ajouter(E element) {
+        elements[fin] = element;
+        fin = (fin + 1);
+        taille++;
+    }
+
+    @Override
+    public void removeif() {
+        E element = elements[debut];
+        if (element.toString().charAt(0) == '-') {
+            elements[debut] = null; // Supprime la référence pour éviter les fuites de mémoire
+            debut = (debut + 1);
+            taille--;
+        }
+    }
+
+    @Override
+    public E retirer() {
+        if (estVide()) {
+            throw new IllegalStateException("La file est vide");
+        }
+        E element = elements[debut];
+        elements[debut] = null; // Supprime la référence pour éviter les fuites de mémoire
+        debut = (debut + 1);
+        taille--;
+        return element;
+    }
+
+    @Override
+    public int taille() {
+        return taille;
+    }
+
+    @Override
+    public boolean estVide() {
+        return taille == 0;
+    }
+}

DEV3.2/ancien_controle/Bulles.java

@@ -0,0 +1,58 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Bulles {
+
+    // Méthode bulle : effectue un parcours
+    public static boolean bulle(Queue<Integer> source, Queue<Integer> destination) {
+        boolean changed = false;
+        if (source.isEmpty()) {
+            return false;
+        }
+
+        int prev = source.poll(); // On récupère le premier élément
+        while (!source.isEmpty()) {
+            int current = source.poll();
+            if (prev > current) { // Si les deux éléments ne sont pas dans l'ordre
+                changed = true;
+                destination.add(current); // Ajouter le plus petit élément
+                prev = prev; // Garder prev pour continuer la comparaison
+            } else {
+                destination.add(prev);
+                prev = current;
+            }
+        }
+        destination.add(prev); // Ajouter le dernier élément
+        return changed;
+    }
+
+    // Méthode tri : utilise bulle pour trier complètement la file
+    public static void tri(Queue<Integer> file) {
+        Queue<Integer> intermediaire = new LinkedList<>();
+        boolean changed;
+        do {
+            changed = bulle(file, intermediaire);
+            // Inverser les files pour un nouveau parcours
+            Queue<Integer> temp = file;
+            file = intermediaire;
+            intermediaire = temp;
+        } while (changed);
+
+        // Les valeurs triées se trouvent dans `file`
+        while (!file.isEmpty()) {
+            System.out.print(file.poll() + " ");
+        }
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+        // Exemple : lecture des entiers passés en arguments
+        Queue<Integer> file = new LinkedList<>();
+        for (String arg : args) {
+            file.add(Integer.parseInt(arg));
+        }
+
+        // Tri et affichage du résultat
+        tri(file);
+    }
+}

DEV3.2/ancien_controle/GeneriqueBulles.java

@@ -0,0 +1,55 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class GeneriqueBulles<T extends Comparable<T>> {
+
+    // Méthode bulle générique
+    public static <T extends Comparable<T>> boolean bulle(Queue<T> source, Queue<T> destination) {
+        boolean changed = false;
+        if (source.isEmpty()) {
+            return false;
+        }
+
+        T prev = source.poll();
+        while (!source.isEmpty()) {
+            T current = source.poll();
+            if (prev.compareTo(current) > 0) {
+                changed = true;
+                destination.add(current);
+                prev = prev;
+            } else {
+                destination.add(prev);
+                prev = current;
+            }
+        }
+        destination.add(prev);
+        return changed;
+    }
+
+    // Méthode tri générique
+    public static <T extends Comparable<T>> void tri(Queue<T> file) {
+        Queue<T> intermediaire = new LinkedList<>();
+        boolean changed;
+        do {
+            changed = bulle(file, intermediaire);
+            Queue<T> temp = file;
+            file = intermediaire;
+            intermediaire = temp;
+        } while (changed);
+
+        while (!file.isEmpty()) {
+            System.out.print(file.poll() + " ");
+        }
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+        Queue<String> file = new LinkedList<>();
+        file.add("Banane");
+        file.add("Pomme");
+        file.add("Orange");
+        file.add("Ananas");
+
+        tri(file);
+    }
+}

DEV3.2/ancien_controle/SimpleDeque.java

@@ -0,0 +1,105 @@
+public class SimpleDeque<T> implements MinimalDeque<T> {
+    private static class Node<T> {
+        T value;
+        Node<T> next;
+        Node<T> prev;
+
+        Node(T value) {
+            this.value = value;
+        }
+    }
+
+    private Node<T> head;
+    private Node<T> tail;
+    private int size;
+
+    public SimpleDeque() {
+        head = null;
+        tail = null;
+        size = 0;
+    }
+
+    @Override
+    public void addFirst(T element) {
+        Node<T> newNode = new Node<>(element);
+        if (isEmpty()) {
+            head = tail = newNode;
+        } else {
+            newNode.next = head;
+            head.prev = newNode;
+            head = newNode;
+        }
+        size++;
+    }
+
+    @Override
+    public void addLast(T element) {
+        Node<T> newNode = new Node<>(element);
+        if (isEmpty()) {
+            head = tail = newNode;
+        } else {
+            newNode.prev = tail;
+            tail.next = newNode;
+            tail = newNode;
+        }
+        size++;
+    }
+
+    @Override
+    public T removeFirst() {
+        if (isEmpty()) {
+            throw new IllegalStateException("Deque is empty");
+        }
+        T value = head.value;
+        head = head.next;
+        if (head != null) {
+            head.prev = null;
+        } else {
+            tail = null;
+        }
+        size--;
+        return value;
+    }
+
+    @Override
+    public T removeLast() {
+        if (isEmpty()) {
+            throw new IllegalStateException("Deque is empty");
+        }
+        T value = tail.value;
+        tail = tail.prev;
+        if (tail != null) {
+            tail.next = null;
+        } else {
+            head = null;
+        }
+        size--;
+        return value;
+    }
+
+    @Override
+    public T peekFirst() {
+        if (isEmpty()) {
+            return null;
+        }
+        return head.value;
+    }
+
+    @Override
+    public T peekLast() {
+        if (isEmpty()) {
+            return null;
+        }
+        return tail.value;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+}

DEV3.2/ancien_controle/TestDequeue.java

@@ -0,0 +1,39 @@
+import java.util.NoSuchElementException;
+
+public class TestDequeue {
+    public static void main(String[] args) {
+        // Créer une instance de SimpleQueue
+        SimpleQueue<Integer> queue = new SimpleQueue<>();
+
+        // Tester le comportement de dequeue sur une file vide
+        System.out.println("Test 1 : Déqueue sur une file vide");
+        try {
+            queue.dequeue(); // Doit lever une exception
+        } catch (NoSuchElementException e) {
+            System.out.println("Exception levée correctement : " + e.getMessage());
+        }
+
+        // Ajouter des éléments à la file
+        queue.enqueue(10);
+        queue.enqueue(20);
+        queue.enqueue(30);
+
+        // Tester dequeue pour retirer des éléments dans l'ordre
+        System.out.println("\nTest 2 : Déqueue sur une file avec des éléments");
+        System.out.println("Défile : " + queue.dequeue()); // Doit afficher 10
+        System.out.println("Défile : " + queue.dequeue()); // Doit afficher 20
+        System.out.println("Défile : " + queue.dequeue()); // Doit afficher 30
+
+        // Vérifier que la file est vide après tous les retraits
+        System.out.println("\nTest 3 : Vérifier si la file est vide après tous les retraits");
+        System.out.println("La file est vide ? " + queue.isEmpty()); // true
+
+        // Retenter dequeue sur une file vide
+        System.out.println("\nTest 4 : Déqueue sur une file vide après avoir vidé tous les éléments");
+        try {
+            queue.dequeue(); // Doit lever une exception
+        } catch (NoSuchElementException e) {
+            System.out.println("Exception levée correctement : " + e.getMessage());
+        }
+    }
+}

DEV3.2/ancien_controle/controle_unit/TestSimpleDeque.java

@@ -0,0 +1,155 @@
+import static org.junit.Assert.assertTrue;
+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 utilise 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<>();
+        d.addFirst(null); // Doit lancer une exception
+    }
+
+    /**
+     * 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<>();
+        d.addLast(null); // Doit lancer une exception
+    }
+
+    /**
+     * Un deque sans élément est vide.
+     * [0.5 point]
+     */
+    @Test
+    public void addNoneIsEmpty() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        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<>();
+        d.addFirst("test");
+        assertFalse(d.isEmpty());
+    }
+
+    /**
+     * Ajouter devant et enlever à la fin respecte l'ordre.
+     * [1 point]
+     */
+    @Test
+    public void pasDeResquilleur() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        d.addFirst("meu");
+        d.addFirst("zo");
+        d.addFirst("bu");
+        d.addFirst("ga");
+
+        assertSame("ga", d.removeLast());
+        assertSame("bu", d.removeLast());
+        assertSame("zo", d.removeLast());
+        assertSame("meu", d.removeLast());
+    }
+
+    /**
+     * Ajouter derrière et enlever au début respecte l'ordre.
+     * [1 point]
+     */
+    @Test
+    public void pasDeResquilleurQuantique() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        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 devant un deque vide.
+     * [1 point]
+     */
+    @Test(expected = NoSuchElementException.class)
+    public void removeFirstFromEmpty() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        d.removeFirst();
+    }
+
+    /**
+     * On ne peut pas enlever derrière un deque vide.
+     * [1 point]
+     */
+    @Test(expected = NoSuchElementException.class)
+    public void removeLastFromEmpty() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        d.removeLast();
+    }
+
+    /**
+     * Ajouter et enlever un seul élément dans les deux sens donne le même résultat.
+     * [2 point]
+     */
+    @Test
+    public void mangerLaBananeParLesDeuxBouts() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        d.addFirst("ga");
+
+        assertSame("ga", d.removeFirst());
+        d.addLast("ga");
+        assertSame("ga", d.removeLast());
+    }
+
+    /**
+     * Invariant de taille
+     * [4 point]
+     */
+    @Test
+    public void invariantTaille() {
+        MinimalDeque<String> d = new SimpleDeque<>();
+        String[] elements = {"ga", "bu", "zo", "meu"};
+        Random random = new Random();
+        int N = random.nextInt(901) + 100;
+
+        for (int i = 0; i < N; i++) {
+            if (random.nextBoolean()) {
+                d.addFirst(elements[random.nextInt(elements.length)]);
+            } else {
+                d.addLast(elements[random.nextInt(elements.length)]);
+            }
+        }
+
+        for (int i = 0; i < N; i++) {
+            if (random.nextBoolean()) {
+                d.removeFirst();
+            } else {
+                d.removeLast();
+            }
+        }
+
+        assertTrue(d.isEmpty());
+    }
+}

DEV3.2/ancien_controle/controle_unit/class.txt

@@ -0,0 +1,151 @@
+export CLASSPATH=".:/usr/share/java/junit.jar:/usr/share/java/hamcrest-core.jar:$CLASSPATH"
+
+
+assertThows
+assertTrue
+assertFalse
+assertEquals
+assertNotEquals
+
+
+Voici une réponse détaillée pour chaque question et une explication de ce qu'il faut compléter :
+
+1) [3 points en tout]
+a) Quel patron de conception est à l'œuvre ici ?
+Réponse :
+Le patron de conception utilisé est l'adaptateur (Adapter Pattern). Cette classe agit comme une enveloppe autour d'une implémentation existante de Deque (comme celle dans java.util) pour qu'elle corresponde à l'interface MinimalDeque demandée.
+
+b) Comment fonctionne cette classe ?
+Réponse :
+La classe SimpleDequeThatsNotCricket délègue toutes ses opérations directement à une instance interne de Deque fournie par java.util. Elle ne réimplémente pas les fonctionnalités mais agit comme une passerelle pour adapter une implémentation existante à une interface spécifique.
+
+2) [-6 à 4 points en tout]
+a)
+a1) Il est possible de décider si un programme Java va s’arrêter quelle que soit son entrée.
+Réponse : F (C'est le problème de l'arrêt, qui est indécidable).
+
+a2) Il est possible de décider si un programme C va s’arrêter quelle que soit son entrée.
+Réponse : F (Même raison que pour Java).
+
+a3) Il est possible de décider si un programme Python ne va pas s’arrêter pour certaines entrées.
+Réponse : F (Le problème de l'arrêt est indécidable pour tous les langages Turing-complets).
+
+b)
+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.
+Réponse : 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.
+Réponse : F (C'est une généralisation trop forte, en raison des limitations de la vérification formelle).
+
+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.
+Réponse : F (Bien que l'IA puisse assister, elle ne garantit pas une vérification formelle).
+
+3) [1 point en tout]
+a) Commande pour lancer les tests si junit.jar et hamcrest-core.jar sont dans le même répertoire :
+bash
+Copier le code
+javac -cp .:junit.jar:hamcrest-core.jar TestSimpleDeque.java
+java -cp .:junit.jar:hamcrest-core.jar org.junit.runner.JUnitCore TestSimpleDeque
+b) Commande pour lancer les tests si les archives sont dans le CLASSPATH :
+bash
+Copier le code
+javac TestSimpleDeque.java
+java org.junit.runner.JUnitCore TestSimpleDeque
+4) [12 points en tout]
+Complétez le fichier TestSimpleDeque.java en fonction des descriptions des tests.
+Test addFirstNull:
+Ajoutez une assertion pour vérifier qu'une exception est levée. Exemple :
+java
+Copier le code
+@Test(expected = NullPointerException.class)
+public void addFirstNull() {
+    MinimalDeque<String> d = new SimpleDeque<>();
+    d.addFirst(null);
+}
+Test addLastNull:
+Pareil que pour addFirstNull.
+
+Test addNoneIsEmpty:
+Vérifiez qu'un Deque vide est effectivement vide. Exemple :
+
+java
+Copier le code
+@Test
+public void addNoneIsEmpty() {
+    MinimalDeque<String> d = new SimpleDeque<>();
+    assertTrue(d.isEmpty());
+}
+Test addOneIsNotEmpty:
+Vérifiez qu'un Deque avec un élément n'est pas vide.
+
+Test pasDeResquilleur:
+Ajoutez des éléments devant, enlevez-les derrière, et vérifiez l'ordre.
+
+Test pasDeResquilleurQuantique:
+Ajoutez des éléments derrière, enlevez-les devant, et vérifiez l'ordre.
+
+Test removeFirstFromEmpty:
+Vérifiez qu'une exception est levée lorsqu'on essaie de retirer un élément d'un Deque vide.
+
+Test removeLastFromEmpty:
+Même logique que removeFirstFromEmpty.
+
+Test mangerLaBananeParLesDeuxBouts:
+Ajoutez un élément, enlevez-le des deux côtés, et vérifiez.
+
+Test invariantTaille:
+Implémentez le test aléatoire avec ajout/suppression jusqu'à ce que le Deque soit vide.
+
+
+Chain of Responsibility
+
+But : Permet à plusieurs objets de traiter une requête, chaque objet ayant la possibilité de la traiter ou de la transmettre.
+Exemple : Système de support technique avec plusieurs niveaux d'escalade.
+Command
+
+But : Encapsule une requête en un objet pour paramétrer des actions, les annuler ou les enregistrer.
+Exemple : Boutons Annuler/Refaire dans un éditeur de texte.
+Interpreter
+
+But : Fournit une représentation grammaticale d'un langage et un interprète pour traiter ses instructions.
+Exemple : Interprétation de scripts dans un moteur de jeu.
+Iterator
+
+But : Fournit un moyen d'accéder séquentiellement aux éléments d'une collection sans exposer sa représentation.
+Exemple : Parcours des éléments d'une liste.
+Mediator
+
+But : Définit un objet pour centraliser la communication entre plusieurs objets.
+Exemple : Gestionnaire de chat dans une application de messagerie.
+Memento
+
+But : Capture l'état interne d'un objet pour pouvoir le restaurer ultérieurement.
+Exemple : Sauvegarde dans un jeu vidéo.
+Observer
+
+But : Définit une relation 1-n où les objets sont notifiés automatiquement lorsqu'un autre objet change d'état.
+Exemple : Notifications pour les abonnés dans un système de messagerie.
+State
+
+But : Permet à un objet de changer son comportement lorsqu'il change d'état.
+Exemple : Système de verrouillage/déverrouillage dans une application.
+Strategy
+
+But : Définit une famille d'algorithmes, les encapsule, et permet de les interchanger dynamiquement.
+Exemple : Algorithmes de tri dans une application.
+Template Method
+
+But : Définit la structure d'un algorithme tout en laissant certaines étapes spécifiques aux sous-classes.
+Exemple : Méthode de rendu dans un moteur de jeu.
+Visitor
+
+But : Sépare un algorithme de la structure des objets sur lesquels il opère.
+Exemple : Calcul de taxes dans un système de commerce électronique.
+
+java org.junit.runner.JUnitCore TestSimpleDeque
+
+javac -cp .:junit.jar:hamcrest-core.jar TestSimpleDeque.java
+java -cp .:junit.jar:hamcrest-core.jar org.junit.runner.JUnitCore TestSimpleDeque
+
+javac TestSimpleDeque.java
+java org.junit.runner.JUnitCore TestSimpleDeque

DEV3.2/ancien_controle/imagine/BullesQueue.java

@@ -0,0 +1,69 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class BullesQueue {
+
+    /**
+     * Effectue un parcours (bulle) dans une file.
+     *
+     * @param source      La file source contenant les entiers à trier.
+     * @param destination La file destination pour stocker le résultat du parcours.
+     * @return true si l'ordre des valeurs a changé, false sinon.
+     */
+    public static boolean bulle(Queue<Integer> source, Queue<Integer> destination) {
+        boolean changed = false;
+        if (source.isEmpty()) {
+            return false;
+        }
+
+        int prev = source.poll(); // Récupère le premier élément
+        while (!source.isEmpty()) {
+            int current = source.poll();
+            if (prev > current) { // Si les éléments ne sont pas dans l'ordre croissant
+                changed = true;
+                destination.add(current);
+                prev = prev; // L'ordre change
+            } else {
+                destination.add(prev); // Ajoute directement dans l'ordre
+                prev = current;
+            }
+        }
+        destination.add(prev); // Ajoute le dernier élément
+        return changed;
+    }
+
+    /**
+     * Trie complètement une file d'entiers en utilisant la méthode bulle.
+     *
+     * @param file La file d'entiers à trier.
+     */
+    public static void tri(Queue<Integer> file) {
+        Queue<Integer> intermediaire = new LinkedList<>();
+        boolean changed;
+
+        do {
+            changed = bulle(file, intermediaire); // Effectue un parcours
+            // Inverse les files
+            Queue<Integer> temp = file;
+            file = intermediaire;
+            intermediaire = temp;
+        } while (changed);
+
+        // Affiche les valeurs triées
+        while (!file.isEmpty()) {
+            System.out.print(file.poll() + " ");
+        }
+        System.out.println();
+    }
+
+    public static void main(String[] args) {
+        // Exemple d'utilisation avec des entiers passés en ligne de commande
+        Queue<Integer> file = new LinkedList<>();
+        for (String arg : args) {
+            file.add(Integer.parseInt(arg));
+        }
+
+        // Trie la file et affiche le résultat
+        tri(file);
+    }
+}

DEV3.2/ancien_controle/imagine/ExempleQueue.java

@@ -0,0 +1,27 @@
+public class ExempleQueue {
+    public static void main(String[] args) {
+        SimpleQueue<Integer> queue = new SimpleQueue<>();
+
+        // Ajouter des éléments à la file
+        queue.enqueue(10);
+        queue.enqueue(20);
+        queue.enqueue(30);
+
+        // Afficher le premier élément
+        System.out.println("Premier élément : " + queue.peek()); // 10
+
+        // Retirer des éléments
+        System.out.println("Défile : " + queue.dequeue()); // 10
+        System.out.println("Défile : " + queue.dequeue()); // 20
+
+        // Afficher la taille restante
+        System.out.println("Taille de la file : " + queue.size()); // 1
+
+        // Vérifier si la file est vide
+        System.out.println("La file est vide ? " + queue.isEmpty()); // false
+
+        // Retirer le dernier élément
+        System.out.println("Défile : " + queue.dequeue()); // 30
+        System.out.println("La file est vide ? " + queue.isEmpty()); // true
+    }
+}

DEV3.2/ancien_controle/imagine/SimpleQueue.java

@@ -0,0 +1,89 @@
+import java.util.NoSuchElementException;
+
+public class SimpleQueue<T> {
+
+    private static class Node<T> {
+        T value;
+        Node<T> next;
+
+        Node(T value) {
+            this.value = value;
+        }
+    }
+
+    private Node<T> head; // Le début de la file
+    private Node<T> tail; // La fin de la file
+    private int size;
+
+    public SimpleQueue() {
+        head = null;
+        tail = null;
+        size = 0;
+    }
+
+    /**
+     * Ajoute un élément à la fin de la file.
+     *
+     * @param element L'élément à ajouter.
+     */
+    public void enqueue(T element) {
+        Node<T> newNode = new Node<>(element);
+        if (isEmpty()) {
+            head = tail = newNode;
+        } else {
+            tail.next = newNode;
+            tail = newNode;
+        }
+        size++;
+    }
+
+    /**
+     * Retire et renvoie l'élément en tête de la file.
+     *
+     * @return L'élément retiré.
+     * @throws NoSuchElementException si la file est vide.
+     */
+    public T dequeue() {
+        if (isEmpty()) {
+            throw new NoSuchElementException("Queue is empty");
+        }
+        T value = head.value;
+        head = head.next;
+        if (head == null) { // Si la file est désormais vide
+            tail = null;
+        }
+        size--;
+        return value;
+    }
+
+    /**
+     * Renvoie l'élément en tête de la file sans le retirer.
+     *
+     * @return L'élément en tête.
+     * @throws NoSuchElementException si la file est vide.
+     */
+    public T peek() {
+        if (isEmpty()) {
+            throw new NoSuchElementException("Queue is empty");
+        }
+        return head.value;
+    }
+
+    /**
+     * Vérifie si la file est vide.
+     *
+     * @return true si la file est vide, false sinon.
+     */
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    /**
+     * Renvoie le nombre d'éléments dans la file.
+     *
+     * @return La taille de la file.
+     */
+    public int size() {
+        return size;
+    }
+}

DEV3.2/dictionnaire/couleurs/Division.java

@@ -0,0 +1,2 @@
+/*Felix-vimalaratnam
+Patrick*/