dhgfhuje

DEV/DEV3.2/TP04_Piles/Q1Main.java

@@ -9,12 +9,12 @@ public class Q1Main{
 		int i;
 		try{
 			for (i=0; i<args.length; i++){
-				if (args[i].equals("*") || args[i].equals("/") || args[i].equals("+") || args[i].equals("-")){
+				if (args[i].equals("x") || args[i].equals("/") || args[i].equals("+") || args[i].equals("-")){
 					int a;
 					int b;
 					a = liste.pop();
 					b = liste.pop();
-					if(args[i].equals("*")){
+					if(args[i].equals("x")){
 						liste.push(b*a);
 					}
 					if(args[i].equals("/")){

DEV/DEV3.2/TP06_Dictionnaires/Q2Main.java

@@ -1,23 +1,26 @@
 import java.util.*;
+import java.io.*;
+import javax.swing.*;
+import java.awt.*;
 
-public class Q1Main{
+public class Q2Main{
     public static void main(String args[]){
-        String nomFichier = 'rgb.txt';
-        HashMap<String,Color> dicoCouleur;
+        String nomFichier = "rgb.txt";
+        HashMap<String,Color> dicoCouleur = new HashMap<>();
+        DefaultListModel<String> listeCouleur = new DefaultListModel<>();
         try{
-            BufferedReader lecture = new BufferedReader(new FileReader("rgb.txt"));
+            BufferedReader lecture = new BufferedReader(new FileReader(nomFichier));
             String ligne;
 
             try {
                 while ((ligne = lecture.readLine()) != null) {
-                    String[] donne = ligne.split("\\s+");
-                    int rouge = Integer.parseInt(data[0]);
-                    int vert = Integer.parseInt(data[1]);
-                    int bleu = Integer.parseInt(data[2]);
-                    Color couleur = Color(rouge, vert, bleu);
-                    String nom = data[3];
-
+                    int rouge = Integer.parseInt(ligne.substring(0,3).trim());
+                    int vert = Integer.parseInt(ligne.substring(4,7).trim());
+                    int bleu = Integer.parseInt(ligne.substring(8,11).trim());
+                    Color couleur = new Color(rouge, vert, bleu);
+                    String nom = ligne.substring(13).trim();
                     dicoCouleur.put(nom, couleur);
+                    listeCouleur.addElement(nom);
                 }
             } catch (IOException e) {
                 System.err.println("Erreur de lecture dans rgb.txt !");
@@ -29,10 +32,17 @@ public class Q1Main{
                 System.err.println("Erreur de fermeture de rgb.txt !");
             }
 
+            JList<String> menuDeroulant = new JList<>(listeCouleur);
+            JScrollPane ascensseur = new JScrollPane(menuDeroulant);
             JFrame fenetre = new JFrame();
             fenetre.setSize(700, 300);
             fenetre.setLocation(0, 0);
             fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+            JPanel contenu = new JPanel(new BorderLayout());
+            contenu.setBackground(Color.RED);
+            contenu.add(ascensseur, BorderLayout.WEST);
+            fenetre.add(contenu, BorderLayout.CENTER);
             fenetre.setVisible(true);
 
         } catch(FileNotFoundException e) {

DEV/DEV3.2/TP07_Arbres/Arbre.java

@@ -0,0 +1,99 @@
+import java.util.*;
+
+public class Arbre<E>{
+    private Noeud<E> racine;
+    private String strArbre;
+
+    public Arbre(){
+    }
+
+    public Arbre(E racine){
+        this.racine = new Noeud<E>(racine);
+    }
+
+    public Arbre(Noeud<E> racine){
+        this.racine = racine;
+    }
+
+    public void setRacine(E racine){
+        this.racine = new Noeud<E>(racine);
+    }
+
+    public Noeud<E> getRacine(){
+        return this.racine;
+    }
+
+    public void afficheArbre(){
+        this.strArbre = "";
+        this.updateStrArbre(this.racine, 0);
+        System.out.println(this.strArbre);
+    }
+
+    public void afficheArbreQ2(){
+        this.strArbre = "";
+        this.updateStrArbreQ2(this.racine);
+        System.out.println(this.strArbre);
+    }
+
+    public void afficheArbreQ3(){
+        this.strArbre = "";
+        this.updateStrArbreQ3(this.racine);
+        System.out.println(this.strArbre);
+    }
+
+    private void updateStrArbreQ3(Noeud<E> noeud){
+        try{
+            String valeur = noeud.getValue().toString();
+            if (valeur.equals("x") || valeur.equals("/") || valeur.equals("+") || valeur.equals("-")){
+                this.strArbre += "(";
+            }
+            else{
+                this.strArbre += valeur;
+            }
+            List<Noeud<E>> fils = noeud.getFils();
+            for (int i=0; i<fils.size(); i++){
+                this.updateStrArbreQ3(fils.get(i));
+                if (i == 0){
+                    this.strArbre += valeur;
+                }
+                if (i == 1){
+                    this.strArbre += ")";
+                }
+            }
+        }
+        catch (NullPointerException e){
+            this.strArbre += "null";
+        }
+    }
+
+    private void updateStrArbreQ2(Noeud<E> noeud){
+        try{
+            this.strArbre += noeud.getValue().toString() + " ";
+            List<Noeud<E>> fils = noeud.getFils();
+            for (int i=0; i<fils.size(); i++){
+                this.updateStrArbreQ2(fils.get(i));
+            }
+        }
+        catch (NullPointerException e){
+            this.strArbre += "null";
+        }
+    }
+
+    private void updateStrArbre(Noeud<E> noeud, int profondeur){
+        int i;
+        this.strArbre += "\n";
+        for (i=0; i<profondeur; i++){
+            this.strArbre += "        ";
+        }
+        try{
+            this.strArbre += noeud.getValue().toString();
+            List<Noeud<E>> fils = noeud.getFils();
+            for (i=0; i<fils.size(); i++){
+                this.updateStrArbre(fils.get(i), profondeur+1);
+            }
+        }
+        catch (NullPointerException e){
+            this.strArbre += "null";
+        }
+    }
+}

DEV/DEV3.2/TP07_Arbres/Noeud.java

@@ -0,0 +1,23 @@
+import java.util.*;
+
+public class Noeud<E>{
+    private E valeur;
+    private List<Noeud<E>> fils;
+
+    public Noeud(E valeur){
+        this.valeur = valeur;
+        this.fils = new ArrayList<Noeud<E>>();
+    }
+
+    public E getValue(){
+        return this.valeur;
+    }
+
+    public List<Noeud<E>> getFils(){
+        return this.fils;
+    }
+
+    public void add(Noeud<E> fils){
+        this.fils.add(fils);
+    }
+}

DEV/DEV3.2/TP07_Arbres/Q1File.java

@@ -0,0 +1,33 @@
+import java.io.*;
+
+public class Q1File extends File{
+
+    private static final long serialVersionUID = 1L;
+
+    public Q1File(String pathname){
+        super(pathname);
+    }
+
+    public static Q1File[] convertion(File[] listeBrute){
+        if (listeBrute == null){
+            return null;
+        }
+        Q1File[] listeFinal = new Q1File[listeBrute.length];
+        for (int i=0; i<listeBrute.length; i++){
+            listeFinal[i] = Q1File.convertion(listeBrute[i]);
+        }
+        return listeFinal;
+    }
+
+    public static Q1File convertion(File repertoire){
+        if (repertoire == null){
+            return null;
+        }
+        return new Q1File(repertoire.getAbsolutePath());
+    }
+
+    @Override
+    public String toString(){
+        return this.getName();
+    }
+}

DEV/DEV3.2/TP07_Arbres/Q1Main.java

@@ -0,0 +1,31 @@
+import java.util.*;
+import java.io.*;
+
+public class Q1Main{
+    private static Arbre<Q1File> arbre;
+
+    public static void main(String args[]){
+        try{
+            Q1File racine = new Q1File(args[0]);
+            Q1Main.arbre = new Arbre<Q1File>(racine);
+            Q1Main.recursive(racine, arbre.getRacine());
+            Q1Main.arbre.afficheArbre();
+        }
+        catch(ArrayIndexOutOfBoundsException e){
+            System.out.println(e);
+        }
+    }
+
+    public static void recursive(Q1File repertoire, Noeud<Q1File> noeud){
+        if (repertoire != null){
+            Q1File[] contenu = Q1File.convertion(repertoire.listFiles());
+            if (contenu != null){
+                for (Q1File item : contenu){
+                    Noeud<Q1File> newFils = new Noeud<Q1File>(item);
+                    noeud.add(newFils);
+                    Q1Main.recursive(item, newFils);
+                }
+            }
+        }
+    }
+}

DEV/DEV3.2/TP07_Arbres/Q2Main.java

@@ -0,0 +1,34 @@
+import javax.swing.*;
+import java.awt.*;
+import java.util.*;
+
+public class Q2Main{
+    public static void main(String[] args) {
+	
+		ArrayDeque<Noeud<String>> liste = new ArrayDeque<>();
+		try{
+			for (int i=0; i<args.length; i++){
+				if (args[i].equals("x") || args[i].equals("/") || args[i].equals("+") || args[i].equals("-")){
+					Noeud<String> a = liste.pop();
+					Noeud<String> b = liste.pop();
+                    Noeud<String> c = new Noeud<String>(args[i]);
+                    c.add(b);
+                    c.add(a);
+                    liste.push(c);
+				}
+				else{
+					liste.push(new Noeud<String>(args[i]));
+				}
+			}
+			Arbre<String> arbre = new Arbre<>(liste.pop());
+            arbre.afficheArbreQ2();
+            arbre.afficheArbreQ3();
+		}
+		catch(NoSuchElementException e){
+			System.out.println("tu ecrit bien");
+		}
+		catch(NumberFormatException e){
+			System.out.println("arretes de mal executer le code");
+		}
+	}
+}

DEV/DEV3.2/TP08_Arbres_suite/Q1Arbre.java

@@ -0,0 +1,79 @@
+import java.util.*;
+
+public class Q1Arbre{
+    private Q1Noeud racine;
+
+    public Q1Arbre(){
+        this.racine = null;
+    }
+
+    public Q1Arbre(int clef){
+        this.racine = new Q1Noeud(clef);
+    }
+
+    public Q1Arbre(Q1Noeud racine){
+        this.racine = racine;
+    }
+
+    public void add(Q1Noeud newNoeud){
+        if (this.racine == null){
+            this.racine = newNoeud;
+        }
+        else{
+            this.racine.add(newNoeud);
+        }
+    }
+
+    public void add(int clef){
+        if (this.racine == null){
+            this.racine = new Q1Noeud(clef);
+        }
+        else{
+            this.racine.add(clef);
+        }
+    }
+
+    private Q1Noeud plusPetit(){
+        if (this.racine != null){
+            Q1Noeud minimum = this.racine;
+            while (minimum.getPetit() != null){
+                minimum = minimum.getPetit();
+            }
+            return minimum;
+        }
+        return this.racine;
+    }
+
+    private Q1Noeud plusGrand(){
+        if (this.racine != null){
+            Q1Noeud maximum = this.racine;
+            while (maximum.getPetit() != null){
+                maximum = maximum.getPetit();
+            }
+            return maximum;
+        }
+        return this.racine;
+    }
+
+    private Q1Noeud suivant(int clef){
+        if (this.racine != null){
+            Q1Noeud maximum = this.racine;
+            while (maximum.getPetit() != null){
+                maximum = maximum.getPetit();
+            }
+            return maximum;
+        }
+        return this.racine;
+    }
+
+    public void affichage(){
+        if (this.racine != null){
+            Q1Noeud plusPetit = this.racine;
+            while (plusPetit.getPetit() != null){
+                plusPetit = plusPetit.getPetit();
+            }
+            System.out.print(plusPetit);
+            while ()
+        }
+    }
+}

DEV/DEV3.2/TP08_Arbres_suite/Q1Main.java

@@ -0,0 +1,19 @@
+import java.util.*;
+import java.io.*;
+
+public class Q1Main{
+
+    public static void main(String[] args){
+        try{
+            Q1Arbre arbre = new Q1Arbre();
+            for (String arg : args){
+                int n = Integer.parseInt(arg);
+                arbre.add(n);
+            }
+            arbre.affichage();
+        }
+        catch(NumberFormatException e){
+            System.out.println("NumberFormatException : Veuillez saisir des nombres en arguments");
+        }
+    }
+}

DEV/DEV3.2/TP08_Arbres_suite/Q1Noeud.java

@@ -0,0 +1,81 @@
+import java.util.*;
+
+public class Q1Noeud{
+    private int clef;
+    private Q1Noeud petit;
+    private Q1Noeud grand;
+    private int occurence;
+
+    public Q1Noeud(int clef){
+        this.clef = clef;
+        this.petit = null;
+        this.grand = null;
+        this.occurence = 1;
+    }
+
+    public int getKey(){
+        return this.clef;
+    }
+
+    public void add(int fils){
+        if (fils < this.clef){
+            if (this.petit == null){
+                this.petit = new Q1Noeud(fils);
+            }
+            else{
+                this.petit.add(fils);
+            }
+        }
+        if (fils > this.clef){
+            if (this.grand == null){
+                this.grand = new Q1Noeud(fils);
+            }
+            else{
+                this.grand.add(fils);
+            }
+        }
+        if (fils == this.clef){
+            this.occurence ++;
+        }
+    }
+
+    public void add(Q1Noeud newNoeud){
+        if (newNoeud.getKey() < this.clef){
+            if (this.petit == null){
+                this.petit = newNoeud;
+            }
+            else{
+                this.petit.add(newNoeud);
+            }
+        }
+        if (newNoeud.getKey() > this.clef){
+            if (this.grand == null){
+                this.grand = newNoeud;
+            }
+            else{
+                this.grand.add(newNoeud);
+            }
+        }
+        if (newNoeud.getKey() == this.clef){
+            this.occurence ++;
+        }
+    }
+
+    public Q1Noeud getPetit(){
+        return this.petit;
+    }
+
+    public Q1Noeud getGrand(){
+        return this.grand;
+    }
+
+    @Override
+    public String toString(){
+        String resultat = "";
+        int i;
+        for (i=0; i<this.occurence; i++){
+            resultat += (this.clef + " ");
+        }
+        return resultat;
+    }
+}

DEV/DEV_Madelaine/stub/exo3/Chef.java

@@ -0,0 +1,68 @@
+import java.util.LinkedHashSet;
+import java.util.Objects;
+import java.util.*;
+
+/** feuille du motif composite */
+public class Chef extends Person {
+
+    private List<Person> listeSubalterne;
+
+    public boolean addSubalterne(Person p){
+        return this.listeSubalterne.add(p);
+    }
+
+
+    
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Chef(int n){
+        super(n);
+        this.listeSubalterne = new ArrayList<>();
+    }
+
+    
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    public int bestPartyWithoutMe(){
+            int fun = 0;
+            for (Person invitee : this.listeSubalterne){
+                fun += invitee.bestParty();
+            }
+        return fun;
+    }
+
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    private int bestPartyWithMe(){
+            int fun = this.getFunFactor();
+            for (Person invitee : this.listeSubalterne){
+                fun += invitee.bestPartyWithoutMe();
+            }
+        return fun;
+    }
+
+    /**
+     *  La meilleure fête est soit sans moi (c'est l'union des meilleures fêtes de mes subalternes). 
+     *  soit c'est la meilleure fête avec moi.
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     *
+     */ 
+    public int bestParty(){
+        return Math.max(this.bestPartyWithMe(), this.bestPartyWithoutMe());
+    }
+    
+}
+
+

DEV/DEV_Madelaine/stub/exo3/Exemple.java

@@ -0,0 +1,36 @@
+public class Exemple {
+     public static void main(String[] args) {
+         // bar 2
+         //   foo 5
+         //     titi 4
+         //     tata 4
+         //     toto 6
+         //   tete 6
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         System.out.println(foo.bestParty());
+         System.out.println(foo.bestPartyWithoutMe());
+         
+         Travailleur tete = new Travailleur(6);
+         // System.out.println(tete.bestParty());
+         // System.out.println(tete.bestPartyWithoutMe());
+
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         bar.addSubalterne(tete);
+         System.out.println(bar.bestParty());
+         //System.out.println(bar.bestPartyWithoutMe());
+     }
+    
+}
+
+
+
+

DEV/DEV_Madelaine/stub/exo3/Exemple2.java

@@ -0,0 +1,33 @@
+public class Exemple2 {
+     public static void main(String[] args) {
+         // Exemple inspiré question Thibault B.
+         // 1
+         //   10
+         //       1
+         //         1
+         //           10
+         //              3
+         //              4
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+         
+         System.out.println(g.bestParty());
+     }
+    
+}
+
+
+
+

DEV/DEV_Madelaine/stub/exo3/Exemple3.java

@@ -0,0 +1,43 @@
+public class Exemple3 {
+     public static void main(String[] args) {
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         Travailleur tete = new Travailleur(6);
+         bar.addSubalterne(tete);
+         
+         Chef x = new Chef(2);
+         x.addSubalterne(g);
+         x.addSubalterne(bar);
+         Chef y = new Chef(39);
+         y.addSubalterne(x);
+         
+         System.out.println(y.bestParty());
+     }
+    
+}
+
+
+
+

DEV/DEV_Madelaine/stub/exo3/Person.java

@@ -0,0 +1,44 @@
+
+/** "Les personnes sont soit des chefs, soit des travailleurs" */
+public abstract class  Person{
+    /**
+    * valeur indiquant le niveau de coolitude de la personne
+    */
+    private int funFactor;
+
+    /**
+     * @return  la valeur indiquant le niveau de coolitude de la personne. plus cete valeur est grande, plus la personne contribue à améliorer l'ambiance dans une fête.
+     *
+     */
+    public int getFunFactor(){
+        return this.funFactor;
+    }
+
+    /**
+     * constructeur 
+     *
+     * <b>NB</b>. Cette méthode ne peut pas être appelé directement pour instancier un objet car la classe est abstraite, mais sert dans les constructeurs de classes dérivées.
+     *
+     * @see Travailleur, Chef
+     */
+    // 
+    public Person(int n){
+        if (n < 0)
+            throw new IllegalArgumentException("Le fun facteur est positif ou nul, vous avez proposé " + n);
+        this.funFactor = n;
+    }
+        
+    /** 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     */ 
+    public abstract int bestPartyWithoutMe();
+
+
+    /** 
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     */ 
+    public abstract int bestParty();
+}
+

DEV/DEV_Madelaine/stub/exo3/Travailleur.java

@@ -0,0 +1,31 @@
+/** feuille du motif composite */
+public class Travailleur extends Person {
+
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Travailleur(int n){
+        super(n);
+    }
+    
+    /** 
+     *
+     * @return fête sans le travailleur
+     */ 
+    public int bestPartyWithoutMe(){
+        return 0;
+    }
+    
+    /**
+     * @return fête avec le travailleur
+     */
+    public int bestParty(){
+        return this.getFunFactor();
+    }
+    
+    
+}
+
+

DEV/DEV_Madelaine/stub/exo4/Chef.java

@@ -0,0 +1,75 @@
+import java.util.LinkedHashSet;
+import java.util.Objects;
+import java.util.*;
+
+/** feuille du motif composite */
+public class Chef extends Person {
+
+    private List<Person> listeSubalterne;
+    private int[] listeFun = {-1, -1, -1}; // 0 best, 1 avec, 2 sans
+
+    public boolean addSubalterne(Person p){
+        return this.listeSubalterne.add(p);
+    }
+
+
+    
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Chef(int n){
+        super(n);
+        this.listeSubalterne = new ArrayList<>();
+    }
+
+    
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    public int bestPartyWithoutMe(){
+        if (this.listeFun[0] < 0){
+            int fun = 0;
+            for (Person invitee : this.listeSubalterne){
+                fun += invitee.bestParty();
+            }
+            this.listeFun[0] = fun;
+        }
+        return this.listeFun[0];
+    }
+
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    private int bestPartyWithMe(){
+        if (this.listeFun[1] < 0){
+            int fun = this.getFunFactor();
+            for (Person invitee : this.listeSubalterne){
+                fun += invitee.bestPartyWithoutMe();
+            }
+            this.listeFun[1] = fun;
+        }
+        return this.listeFun[1];
+    }
+
+    /**
+     *  La meilleure fête est soit sans moi (c'est l'union des meilleures fêtes de mes subalternes). 
+     *  soit c'est la meilleure fête avec moi.
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     *
+     */ 
+    public int bestParty(){
+        return Math.max(this.bestPartyWithMe(), this.bestPartyWithoutMe());
+    }
+    
+}
+
+

DEV/DEV_Madelaine/stub/exo4/Exemple.java

@@ -0,0 +1,36 @@
+public class Exemple {
+     public static void main(String[] args) {
+         // bar 2
+         //   foo 5
+         //     titi 4
+         //     tata 4
+         //     toto 6
+         //   tete 6
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         System.out.println(foo.bestParty());
+         System.out.println(foo.bestPartyWithoutMe());
+         
+         Travailleur tete = new Travailleur(6);
+         // System.out.println(tete.bestParty());
+         // System.out.println(tete.bestPartyWithoutMe());
+
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         bar.addSubalterne(tete);
+         System.out.println(bar.bestParty());
+         //System.out.println(bar.bestPartyWithoutMe());
+     }
+    
+}
+
+
+
+

DEV/DEV_Madelaine/stub/exo4/Exemple2.java

@@ -0,0 +1,33 @@
+public class Exemple2 {
+     public static void main(String[] args) {
+         // Exemple inspiré question Thibault B.
+         // 1
+         //   10
+         //       1
+         //         1
+         //           10
+         //              3
+         //              4
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+         
+         System.out.println(g.bestParty());
+     }
+    
+}
+
+
+
+

DEV/DEV_Madelaine/stub/exo4/Exemple3.java

@@ -0,0 +1,43 @@
+public class Exemple3 {
+     public static void main(String[] args) {
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         Travailleur tete = new Travailleur(6);
+         bar.addSubalterne(tete);
+         
+         Chef x = new Chef(2);
+         x.addSubalterne(g);
+         x.addSubalterne(bar);
+         Chef y = new Chef(39);
+         y.addSubalterne(x);
+         
+         System.out.println(y.bestParty());
+     }
+    
+}
+
+
+
+

DEV/DEV_Madelaine/stub/exo4/Person.java

@@ -0,0 +1,44 @@
+
+/** "Les personnes sont soit des chefs, soit des travailleurs" */
+public abstract class  Person{
+    /**
+    * valeur indiquant le niveau de coolitude de la personne
+    */
+    private int funFactor;
+
+    /**
+     * @return  la valeur indiquant le niveau de coolitude de la personne. plus cete valeur est grande, plus la personne contribue à améliorer l'ambiance dans une fête.
+     *
+     */
+    public int getFunFactor(){
+        return this.funFactor;
+    }
+
+    /**
+     * constructeur 
+     *
+     * <b>NB</b>. Cette méthode ne peut pas être appelé directement pour instancier un objet car la classe est abstraite, mais sert dans les constructeurs de classes dérivées.
+     *
+     * @see Travailleur, Chef
+     */
+    // 
+    public Person(int n){
+        if (n < 0)
+            throw new IllegalArgumentException("Le fun facteur est positif ou nul, vous avez proposé " + n);
+        this.funFactor = n;
+    }
+        
+    /** 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     */ 
+    public abstract int bestPartyWithoutMe();
+
+
+    /** 
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     */ 
+    public abstract int bestParty();
+}
+

DEV/DEV_Madelaine/stub/exo4/Travailleur.java

@@ -0,0 +1,31 @@
+/** feuille du motif composite */
+public class Travailleur extends Person {
+
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Travailleur(int n){
+        super(n);
+    }
+    
+    /** 
+     *
+     * @return fête sans le travailleur
+     */ 
+    public int bestPartyWithoutMe(){
+        return 0;
+    }
+    
+    /**
+     * @return fête avec le travailleur
+     */
+    public int bestParty(){
+        return this.getFunFactor();
+    }
+    
+    
+}
+
+

DEV/DEV_Madelaine/stub/exo5/Chef.java

@@ -0,0 +1,75 @@
+import java.util.LinkedHashSet;
+import java.util.Objects;
+import java.util.*;
+
+/** feuille du motif composite */
+public class Chef extends Person {
+
+    private List<Person> listeSubalterne;
+    private int[] listeFun = {-1, -1, -1}; // 0 best, 1 avec, 2 sans
+
+    public boolean addSubalterne(Person p){
+        return this.listeSubalterne.add(p);
+    }
+
+
+    
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Chef(int n){
+        super(n);
+        this.listeSubalterne = new ArrayList<>();
+    }
+
+    
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    public int bestPartyWithoutMe(){
+        if (this.listeFun[0] < 0){
+            int fun = 0;
+            for (Person invitee : this.listeSubalterne){
+                fun += invitee.bestParty();
+            }
+            this.listeFun[0] = fun;
+        }
+        return this.listeFun[0];
+    }
+
+    /** 
+     * La meilleure fête avec moi, c'est la meilleure fête sans mes subalternes pour eux plus moi. 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     *
+     */ 
+    private int bestPartyWithMe(){
+        if (this.listeFun[1] < 0){
+            int fun = this.getFunFactor();
+            for (Person invitee : this.listeSubalterne){
+                fun += invitee.bestPartyWithoutMe();
+            }
+            this.listeFun[1] = fun;
+        }
+        return this.listeFun[1];
+    }
+
+    /**
+     *  La meilleure fête est soit sans moi (c'est l'union des meilleures fêtes de mes subalternes). 
+     *  soit c'est la meilleure fête avec moi.
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     *
+     */ 
+    public int bestParty(){
+        return Math.max(this.bestPartyWithMe(), this.bestPartyWithoutMe());
+    }
+    
+}
+
+

DEV/DEV_Madelaine/stub/exo5/Exemple.java

@@ -0,0 +1,36 @@
+public class Exemple {
+     public static void main(String[] args) {
+         // bar 2
+         //   foo 5
+         //     titi 4
+         //     tata 4
+         //     toto 6
+         //   tete 6
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         System.out.println(foo.bestParty());
+         System.out.println(foo.bestPartyWithoutMe());
+         
+         Travailleur tete = new Travailleur(6);
+         // System.out.println(tete.bestParty());
+         // System.out.println(tete.bestPartyWithoutMe());
+
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         bar.addSubalterne(tete);
+         System.out.println(bar.bestParty());
+         //System.out.println(bar.bestPartyWithoutMe());
+     }
+    
+}
+
+
+
+

DEV/DEV_Madelaine/stub/exo5/Exemple2.java

@@ -0,0 +1,33 @@
+public class Exemple2 {
+     public static void main(String[] args) {
+         // Exemple inspiré question Thibault B.
+         // 1
+         //   10
+         //       1
+         //         1
+         //           10
+         //              3
+         //              4
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+         
+         System.out.println(g.bestParty());
+     }
+    
+}
+
+
+
+

DEV/DEV_Madelaine/stub/exo5/Exemple3.java

@@ -0,0 +1,43 @@
+public class Exemple3 {
+     public static void main(String[] args) {
+
+         Travailleur a = new Travailleur(3);
+         Travailleur b = new Travailleur(4);
+         Chef c = new Chef(10);
+         c.addSubalterne(a);
+         c.addSubalterne(b);
+         Chef d = new Chef(1);
+         d.addSubalterne(c);
+         Chef e = new Chef(1);
+         e.addSubalterne(d);
+         Chef f = new Chef(10);
+         f.addSubalterne(e);
+         Chef g = new Chef(1);
+         g.addSubalterne(f);
+
+         Travailleur titi = new Travailleur(4);
+         Travailleur tata = new Travailleur(4);
+         Travailleur toto = new Travailleur(6);
+         Chef foo = new Chef(5);
+         foo.addSubalterne(titi);
+         foo.addSubalterne(tata);
+         foo.addSubalterne(toto);
+         Chef bar = new Chef(2);
+         bar.addSubalterne(foo);
+         Travailleur tete = new Travailleur(6);
+         bar.addSubalterne(tete);
+         
+         Chef x = new Chef(2);
+         x.addSubalterne(g);
+         x.addSubalterne(bar);
+         Chef y = new Chef(39);
+         y.addSubalterne(x);
+         
+         System.out.println(y.bestParty());
+     }
+    
+}
+
+
+
+

DEV/DEV_Madelaine/stub/exo5/Person.java

@@ -0,0 +1,44 @@
+
+/** "Les personnes sont soit des chefs, soit des travailleurs" */
+public abstract class  Person{
+    /**
+    * valeur indiquant le niveau de coolitude de la personne
+    */
+    private int funFactor;
+
+    /**
+     * @return  la valeur indiquant le niveau de coolitude de la personne. plus cete valeur est grande, plus la personne contribue à améliorer l'ambiance dans une fête.
+     *
+     */
+    public int getFunFactor(){
+        return this.funFactor;
+    }
+
+    /**
+     * constructeur 
+     *
+     * <b>NB</b>. Cette méthode ne peut pas être appelé directement pour instancier un objet car la classe est abstraite, mais sert dans les constructeurs de classes dérivées.
+     *
+     * @see Travailleur, Chef
+     */
+    // 
+    public Person(int n){
+        if (n < 0)
+            throw new IllegalArgumentException("Le fun facteur est positif ou nul, vous avez proposé " + n);
+        this.funFactor = n;
+    }
+        
+    /** 
+     *
+     * @return retourne la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique, mais pas elle.
+     */ 
+    public abstract int bestPartyWithoutMe();
+
+
+    /** 
+     *
+     * @return la valeur de la meilleure fête en invitant seulement les gens dont cette personne est le ou la supérieure hiérarchique (peut-être avec elle).
+     */ 
+    public abstract int bestParty();
+}
+