fin piles

DEV3.2/Listes/LuminanceApp.java

@@ -0,0 +1,96 @@
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+public class LuminanceApp extends JFrame {
+    private final List<Color> colors = new ArrayList<>(); // Liste des couleurs des parallélogrammes
+    private final int parallelogramWidth = 100;
+    private final int parallelogramHeight = 50;
+    
+    public LuminanceApp() {
+        setTitle("Luminance App");
+        setSize(600, 400);
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        setLocationRelativeTo(null);
+
+        // Générer 10 couleurs aléatoires et les ajouter à la liste
+        generateRandomColors(10);
+
+        // Ajouter un MouseListener pour détecter les clics
+        addMouseListener(new MouseAdapter() {
+            @Override
+            public void mouseClicked(MouseEvent e) {
+                handleMouseClick(e.getX(), e.getY());
+            }
+        });
+    }
+
+    // Génération des couleurs aléatoires
+    private void generateRandomColors(int numberOfColors) {
+        Random random = new Random();
+        for (int i = 0; i < numberOfColors; i++) {
+            Color color = new Color(random.nextInt(256), random.nextInt(256), random.nextInt(256));
+            colors.add(color);
+        }
+    }
+
+    // Gestion du clic de souris
+    private void handleMouseClick(int x, int y) {
+        int index = getClickedParallelogramIndex(x, y);
+        if (index >= 0 && index < colors.size()) {
+            Color color = colors.remove(index); // Supprimer la couleur cliquée
+            float luminance = calculateLuminance(color);
+            System.out.println("Luminance de la couleur supprimée : " + luminance);
+            repaint(); // Redessiner la fenêtre avec les parallélogrammes restants
+        }
+    }
+
+    // Calcul de la luminance selon la formule donnée
+    private float calculateLuminance(Color color) {
+        return 21 * color.getRed() + 72 * color.getGreen() + 7 * color.getBlue();
+    }
+
+    // Récupère l'index du parallélogramme cliqué
+    private int getClickedParallelogramIndex(int x, int y) {
+        int posX = 50;
+        int posY = 50;
+        for (int i = 0; i < colors.size(); i++) {
+            if (x >= posX && x <= posX + parallelogramWidth && y >= posY && y <= posY + parallelogramHeight) {
+                return i;
+            }
+            posY += parallelogramHeight + 10; // Espace entre les parallélogrammes
+        }
+        return -1;
+    }
+
+    // Dessin des parallélogrammes dans la fenêtre
+    @Override
+    public void paint(Graphics g) {
+        super.paint(g);
+        int posX = 50;
+        int posY = 50;
+        for (Color color : colors) {
+            g.setColor(color);
+            drawParallelogram(g, posX, posY, parallelogramWidth, parallelogramHeight);
+            posY += parallelogramHeight + 10; // Espacement vertical
+        }
+    }
+
+    // Dessin d'un parallélogramme
+    private void drawParallelogram(Graphics g, int x, int y, int width, int height) {
+        int[] xPoints = {x, x + width - 20, x + width, x + 20};
+        int[] yPoints = {y, y, y + height, y + height};
+        g.fillPolygon(xPoints, yPoints, 4);
+    }
+
+    public static void main(String[] args) {
+        SwingUtilities.invokeLater(() -> {
+            LuminanceApp app = new LuminanceApp();
+            app.setVisible(true);
+        });
+    }
+}

DEV3.2/Listes/MaListeChainee.java

@@ -0,0 +1,94 @@
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public class MaListeChainee<E> implements Iterable<E> {
+    private Node<E> head;    // Premier élément de la liste
+    private int size;        // Taille de la liste
+
+    // Classe interne représentant un nœud
+    private static class Node<E> {
+        E data;
+        Node<E> next;
+
+        Node(E data) {
+            this.data = data;
+        }
+    }
+
+    // Ajoute un élément à la fin de la liste
+    public void add(E element) {
+        Node<E> newNode = new Node<>(element);
+        if (head == null) {
+            head = newNode;
+        } else {
+            Node<E> current = head;
+            while (current.next != null) {
+                current = current.next;
+            }
+            current.next = newNode;
+        }
+        size++;
+    }
+
+    // Ajoute un élément à une position spécifique
+    public void add(int index, E element) {
+        if (index < 0 || index > size) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
+        }
+
+        Node<E> newNode = new Node<>(element);
+        if (index == 0) {
+            newNode.next = head;
+            head = newNode;
+        } else {
+            Node<E> current = head;
+            for (int i = 0; i < index - 1; i++) {
+                current = current.next;
+            }
+            newNode.next = current.next;
+            current.next = newNode;
+        }
+        size++;
+    }
+
+    // Retourne l'élément à une position spécifique
+    public E get(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
+        }
+
+        Node<E> current = head;
+        for (int i = 0; i < index; i++) {
+            current = current.next;
+        }
+        return current.data;
+    }
+
+    // Retourne la taille de la liste
+    public int size() {
+        return size;
+    }
+
+    // Méthode pour l'itération
+    @Override
+    public Iterator<E> iterator() {
+        return new Iterator<E>() {
+            private Node<E> current = head;
+
+            @Override
+            public boolean hasNext() {
+                return current != null;
+            }
+
+            @Override
+            public E next() {
+                if (!hasNext()) {
+                    throw new NoSuchElementException();
+                }
+                E data = current.data;
+                current = current.next;
+                return data;
+            }
+        };
+    }
+}

DEV3.2/Listes/MaListeTableau.java

@@ -0,0 +1,78 @@
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public class MaListeTableau<E> implements Iterable<E> {
+    private E[] elements;   // Tableau pour stocker les éléments
+    private int size = 0;   // Nombre d'éléments dans la liste
+
+    // Taille initiale du tableau
+    private static final int INITIAL_CAPACITY = 10;
+
+    // Constructeur
+    public MaListeTableau() {
+        elements = (E[]) new Object[INITIAL_CAPACITY];
+    }
+
+    // Ajoute un élément à la fin de la liste
+    public void add(E element) {
+        ensureCapacity();
+        elements[size++] = element;
+    }
+
+    // Ajoute un élément à une position spécifique
+    public void add(int index, E element) {
+        if (index < 0 || index > size) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
+        }
+        ensureCapacity();
+        // Décaler les éléments vers la droite pour insérer à l'index
+        for (int i = size; i > index; i--) {
+            elements[i] = elements[i - 1];
+        }
+        elements[index] = element;
+        size++;
+    }
+
+    // Retourne l'élément à une position spécifique
+    public E get(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
+        }
+        return elements[index];
+    }
+
+    // Retourne la taille de la liste
+    public int size() {
+        return size;
+    }
+
+    // Assure la capacité du tableau pour accueillir plus d'éléments
+    private void ensureCapacity() {
+        if (size == elements.length) {
+            E[] newElements = (E[]) new Object[elements.length * 2];
+            System.arraycopy(elements, 0, newElements, 0, elements.length);
+            elements = newElements;
+        }
+    }
+
+    // Méthode pour l'itération
+    @Override
+    public Iterator<E> iterator() {
+        return new Iterator<E>() {
+            private int currentIndex = 0;
+
+            @Override
+            public boolean hasNext() {
+                return currentIndex < size;
+            }
+
+            @Override
+            public E next() {
+                if (!hasNext()) {
+                    throw new NoSuchElementException();
+                }
+                return elements[currentIndex++];
+            }
+        };
+    }
+}

DEV3.2/Piles/Arithmetique.java

@@ -0,0 +1,58 @@
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+public class Arithmetique {
+
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            System.out.println("Veuillez fournir une expression en notation polonaise inversée.");
+            return;
+        }
+
+        Deque<Integer> stack = new ArrayDeque<>();
+
+        try {
+            for (String token : args) {
+                switch (token) {
+                    case "+":
+                        // Addition
+                        stack.push(stack.pop() + stack.pop());
+                        break;
+                    case "-":
+                        // Soustraction (attention à l'ordre)
+                        int b = stack.pop();
+                        int a = stack.pop();
+                        stack.push(a - b);
+                        break;
+                    case "x":
+                        // Multiplication
+                        stack.push(stack.pop() * stack.pop());
+                        break;
+                    case "/":
+                        // Division (attention à l'ordre)
+                        b = stack.pop();
+                        a = stack.pop();
+                        if (b == 0) {
+                            throw new ArithmeticException("Division par zéro");
+                        }
+                        stack.push(a / b);
+                        break;
+                    default:
+                        // Si ce n'est pas un opérateur, alors c'est un nombre
+                        stack.push(Integer.parseInt(token));
+                        break;
+                }
+            }
+
+            // Le résultat final doit être le seul élément restant sur la pile
+            if (stack.size() == 1) {
+                System.out.println("= " + stack.pop());
+            } else {
+                System.out.println("Erreur : Expression incorrecte.");
+            }
+
+        } catch (Exception e) {
+            System.out.println("Erreur lors de l'évaluation de l'expression : " + e.getMessage());
+        }
+    }
+}

DEV3.2/Piles/chaine/Arithmetique.java

@@ -0,0 +1,56 @@
+public class Arithmetique {
+
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            System.out.println("Veuillez fournir une expression en notation polonaise inversée.");
+            return;
+        }
+
+        // Utilisation de notre implémentation PileChainee pour la pile
+        Pile<Integer> stack = new PileChainee<>();
+
+        try {
+            for (String token : args) {
+                switch (token) {
+                    case "+":
+                        // Addition
+                        stack.push(stack.pop() + stack.pop());
+                        break;
+                    case "-":
+                        // Soustraction (attention à l'ordre)
+                        int b = stack.pop();
+                        int a = stack.pop();
+                        stack.push(a - b);
+                        break;
+                    case "x":
+                        // Multiplication
+                        stack.push(stack.pop() * stack.pop());
+                        break;
+                    case "/":
+                        // Division (attention à l'ordre)
+                        b = stack.pop();
+                        a = stack.pop();
+                        if (b == 0) {
+                            throw new ArithmeticException("Division par zéro");
+                        }
+                        stack.push(a / b);
+                        break;
+                    default:
+                        // Si ce n'est pas un opérateur, alors c'est un nombre
+                        stack.push(Integer.parseInt(token));
+                        break;
+                }
+            }
+
+            // Le résultat final doit être le seul élément restant sur la pile
+            if (stack.size() == 1) {
+                System.out.println("= " + stack.pop());
+            } else {
+                System.out.println("Erreur : Expression incorrecte.");
+            }
+
+        } catch (Exception e) {
+            System.out.println("Erreur lors de l'évaluation de l'expression : " + e.getMessage());
+        }
+    }
+}

DEV3.2/Piles/chaine/Pile.java

@@ -0,0 +1,7 @@
+// Interface représentant une pile
+public interface Pile<E> {
+    void push(E element);      // Ajoute un élément en haut de la pile
+    E pop();                   // Retire et retourne l'élément en haut de la pile
+    int size();                // Retourne la taille de la pile
+    boolean isEmpty();         // Vérifie si la pile est vide
+}

DEV3.2/Piles/chaine/PileChainee.java

@@ -0,0 +1,43 @@
+// Classe PileChainee utilisant une liste chaînée pour stocker les éléments
+public class PileChainee<E> implements Pile<E> {
+    private static class Node<E> {
+        E data;
+        Node<E> next;
+
+        Node(E data) {
+            this.data = data;
+        }
+    }
+
+    private Node<E> top;  // Le sommet de la pile
+    private int size = 0; // Taille de la pile
+
+    @Override
+    public void push(E element) {
+        Node<E> newNode = new Node<>(element);
+        newNode.next = top; // Le nouvel élément pointe vers l'ancien sommet
+        top = newNode;      // Le nouvel élément devient le sommet de la pile
+        size++;
+    }
+
+    @Override
+    public E pop() {
+        if (isEmpty()) {
+            throw new IllegalStateException("La pile est vide");
+        }
+        E data = top.data; // Récupère la donnée du sommet
+        top = top.next;    // Le sommet devient l'élément suivant
+        size--;
+        return data;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+}

DEV3.2/Piles/tableau/Arithmetique.java

@@ -0,0 +1,56 @@
+public class Arithmetique {
+
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            System.out.println("Veuillez fournir une expression en notation polonaise inversée.");
+            return;
+        }
+
+        // Utilisation de l'implémentation PileTableau pour la pile
+        Pile<Integer> stack = new PileTableau<>();
+
+        try {
+            for (String token : args) {
+                switch (token) {
+                    case "+":
+                        // Addition
+                        stack.push(stack.pop() + stack.pop());
+                        break;
+                    case "-":
+                        // Soustraction (attention à l'ordre)
+                        int b = stack.pop();
+                        int a = stack.pop();
+                        stack.push(a - b);
+                        break;
+                    case "x":
+                        // Multiplication
+                        stack.push(stack.pop() * stack.pop());
+                        break;
+                    case "/":
+                        // Division (attention à l'ordre)
+                        b = stack.pop();
+                        a = stack.pop();
+                        if (b == 0) {
+                            throw new ArithmeticException("Division par zéro");
+                        }
+                        stack.push(a / b);
+                        break;
+                    default:
+                        // Si ce n'est pas un opérateur, alors c'est un nombre
+                        stack.push(Integer.parseInt(token));
+                        break;
+                }
+            }
+
+            // Le résultat final doit être le seul élément restant sur la pile
+            if (stack.size() == 1) {
+                System.out.println("= " + stack.pop());
+            } else {
+                System.out.println("Erreur : Expression incorrecte.");
+            }
+
+        } catch (Exception e) {
+            System.out.println("Erreur lors de l'évaluation de l'expression : " + e.getMessage());
+        }
+    }
+}

DEV3.2/Piles/tableau/Pile.java

@@ -0,0 +1,7 @@
+// Interface représentant une pile
+public interface Pile<E> {
+    void push(E element);      // Ajoute un élément en haut de la pile
+    E pop();                   // Retire et retourne l'élément en haut de la pile
+    int size();                // Retourne la taille de la pile
+    boolean isEmpty();         // Vérifie si la pile est vide
+}

DEV3.2/Piles/tableau/PileTableau.java

@@ -0,0 +1,47 @@
+// Classe PileTableau utilisant un tableau pour stocker les éléments
+public class PileTableau<E> implements Pile<E> {
+    private static final int INITIAL_CAPACITY = 10;
+    private E[] elements;
+    private int size = 0;
+
+    @SuppressWarnings("unchecked")
+    public PileTableau() {
+        elements = (E[]) new Object[INITIAL_CAPACITY]; // Création du tableau initial
+    }
+
+    @Override
+    public void push(E element) {
+        ensureCapacity(); // Redimensionne si nécessaire
+        elements[size++] = element; // Ajoute l'élément en haut de la pile
+    }
+
+    @Override
+    public E pop() {
+        if (isEmpty()) {
+            throw new IllegalStateException("La pile est vide");
+        }
+        E element = elements[--size]; // Récupère l'élément en haut de la pile
+        elements[size] = null; // Supprime la référence pour éviter les fuites de mémoire
+        return element;
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    // Redimensionne le tableau si nécessaire
+    private void ensureCapacity() {
+        if (size == elements.length) {
+            @SuppressWarnings("unchecked")
+            E[] newElements = (E[]) new Object[elements.length * 2]; // Double la capacité
+            System.arraycopy(elements, 0, newElements, 0, elements.length);
+            elements = newElements;
+        }
+    }
+}