manque l'ex 5

TP5/stub/exo3/Chef.java

@@ -0,0 +1,57 @@
+import java.util.LinkedHashSet;
+import java.util.Objects;
+import java.util.ArrayList;
+import java.util.List;
+
+/** feuille du motif composite */
+public class Chef extends Person {
+    private final List<Person> subalternes;
+
+    /** constructeur
+     *
+     * @param n fun factor
+     */
+    public Chef(int n) {
+        super(n);
+        this.subalternes = new ArrayList<>();
+    }
+
+    /**
+     * Ajoute un subalterne au chef
+     * @param p la personne à ajouter
+     */
+    public void addSubalterne(Person p) {
+        if (p != null) subalternes.add(p);
+    }
+
+    /**
+     * 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.
+     */
+    @Override
+    public int bestPartyWithoutMe() {
+        int sum = 0;
+        for (Person subalterne : subalternes) {
+            sum += subalterne.bestParty(); // Additionne les meilleures fêtes de chaque subalterne
+        }
+        return sum;
+    }
+
+    /**
+     * 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).
+     */
+    @Override
+    public int bestParty() {
+        int withMe = getFunFactor(); // Inclure le chef
+        for (Person subalterne : subalternes) {
+            withMe += subalterne.bestPartyWithoutMe(); // Ajouter les meilleures fêtes sans chaque subalterne
+        }
+
+        int withoutMe = bestPartyWithoutMe(); // Meilleure fête sans inclure le chef
+        return Math.max(withMe, withoutMe); // Retourner la meilleure des deux options
+    }
+}

TP5/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());
+     }
+    
+}
+
+
+
+

TP5/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());
+     }
+    
+}
+
+
+
+

TP5/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());
+     }
+    
+}
+
+
+
+

TP5/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();
+}
+

TP5/stub/exo3/Travailleur.java

@@ -0,0 +1,27 @@
+/** 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
+     */
+    @Override
+    public int bestPartyWithoutMe() {
+        return 0; // Contribution nulle si le travailleur n'est pas invité
+    }
+
+    /**
+     * @return fête avec le travailleur
+     */
+    @Override
+    public int bestParty() {
+        return getFunFactor(); // Contribution égale au fun factor si le travailleur est invité
+    }
+}

TP5/stub/exo4/Chef.java

@@ -0,0 +1,69 @@
+import java.util.LinkedHashSet;
+import java.util.Objects;
+
+/** feuille du motif composite */
+public class Chef extends Person {
+    private final LinkedHashSet<Person> subalternes;
+
+    // Attributs pour mémoriser les résultats
+    private Integer bestPartyMemo = null;
+    private Integer bestPartyWithoutMeMemo = null;
+
+    /** constructeur
+     *
+     * @param n fun factor
+     */
+    public Chef(int n) {
+        super(n);
+        this.subalternes = new LinkedHashSet<>();
+    }
+
+    /**
+     * Ajoute un subalterne au chef
+     *
+     * @param p la personne à ajouter
+     * @return true si le subalterne a été ajouté, false sinon
+     */
+    public boolean addSubalterne(Person p) {
+        return subalternes.add(Objects.requireNonNull(p));
+    }
+
+    /**
+     * 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.
+     */
+    @Override
+    public int bestPartyWithoutMe() {
+        // Vérifie si la valeur est déjà calculée
+        if (this.bestPartyWithoutMeMemo == null) {
+            int sum = 0;
+            for (Person subalterne : subalternes) {
+                sum += subalterne.bestParty(); // Appelle uniquement bestParty(), qui est déjà mémorisé
+            }
+            this.bestPartyWithoutMeMemo = sum; // Mémorise le résultat
+        }
+        return this.bestPartyWithoutMeMemo;
+    }
+
+    /**
+     * 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).
+     */
+    @Override
+    public int bestParty() {
+        // Vérifie si la valeur est déjà calculée
+        if (this.bestPartyMemo == null) {
+            int withMe = getFunFactor();
+            for (Person subalterne : subalternes) {
+                withMe += subalterne.bestPartyWithoutMe(); // Inclut uniquement bestPartyWithoutMe(), déjà mémorisé
+            }
+
+            int withoutMe = bestPartyWithoutMe(); // Utilise la version mémorisée
+            this.bestPartyMemo = Math.max(withMe, withoutMe); // Mémorise le meilleur résultat
+        }
+        return this.bestPartyMemo;
+    }
+}

TP5/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());
+     }
+    
+}
+
+
+
+

TP5/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());
+     }
+    
+}
+
+
+
+

TP5/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());
+     }
+    
+}
+
+
+
+

TP5/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();
+}
+

TP5/stub/exo4/Travailleur.java

@@ -0,0 +1,37 @@
+/** feuille du motif composite */
+public class Travailleur extends Person {
+    // Attributs pour mémoriser les résultats
+    private Integer bestPartyMemo = null;
+    private Integer bestPartyWithoutMeMemo = null;
+
+    /** constructeur
+     *
+     * @param n fun factor
+     */
+    public Travailleur(int n) {
+        super(n);
+    }
+
+    /** 
+     * @return fête sans le travailleur
+     */
+    @Override
+    public int bestPartyWithoutMe() {
+        if (this.bestPartyWithoutMeMemo == null) { // Si non calculé
+            this.bestPartyWithoutMeMemo = 0; // Toujours 0 car le travailleur n'est pas invité
+        }
+        return this.bestPartyWithoutMeMemo;
+    }
+
+    /**
+     * @return fête avec le travailleur
+     */
+    @Override
+    public int bestParty() {
+        if (this.bestPartyMemo == null) { // Si non calculé
+            this.bestPartyMemo = getFunFactor(); // La fête inclut uniquement le travailleur
+        }
+        return this.bestPartyMemo;
+    }
+}
+

TP5/stub/exo5/Chef.java

@@ -0,0 +1,48 @@
+import java.util.LinkedHashSet;
+import java.util.Objects;
+
+/** feuille du motif composite */
+public class Chef extends Person {
+
+
+    public boolean addSubalterne(Person p){
+        
+    }
+
+
+    
+    /** constructeur
+     *
+     * @param n fun factor
+     *
+     */ 
+    public Chef(int n){
+        super(n);
+        // d'autres choses peut-être.
+    }
+
+    
+    /** 
+     * 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(){
+        // to do
+    }
+
+    /**
+     *  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(){
+        // to do
+    }
+    
+}
+
+

TP5/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());
+     }
+    
+}
+
+
+
+

TP5/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());
+     }
+    
+}
+
+
+
+

TP5/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());
+     }
+    
+}
+
+
+
+

TP5/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();
+}
+

TP5/stub/exo5/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 null;
+    }
+    
+    /**
+     * @return fête avec le travailleur
+     */
+    public int bestParty(){
+        // return null;
+    }
+    
+    
+}
+
+