diff --git a/TP4/stub/0Bad/Base.class b/TP4/stub/0Bad/Base.class new file mode 100644 index 0000000..c0797ce Binary files /dev/null and b/TP4/stub/0Bad/Base.class differ diff --git a/TP4/stub/0Bad/Base.java b/TP4/stub/0Bad/Base.java new file mode 100644 index 0000000..5e6a4cf --- /dev/null +++ b/TP4/stub/0Bad/Base.java @@ -0,0 +1,4 @@ +// juste un type énuméré pour nommer les bases +public enum Base { + A,C,G,T +} diff --git a/TP4/stub/0Bad/Exemple.class b/TP4/stub/0Bad/Exemple.class new file mode 100644 index 0000000..ca95c9e Binary files /dev/null and b/TP4/stub/0Bad/Exemple.class differ diff --git a/TP4/stub/0Bad/Exemple.java b/TP4/stub/0Bad/Exemple.java new file mode 100644 index 0000000..ae72d5c --- /dev/null +++ b/TP4/stub/0Bad/Exemple.java @@ -0,0 +1,31 @@ +// Fichier Exemple pour le premier exercice sur l'ADN + +public class Exemple{ + public static void main(String[] args) { + // codon GCT code l'analine https://en.wikipedia.org/wiki/DNA_codon_table + // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon + + System.out.println("construction du brin GCTTAG"); + MonMaillon l = new MonMaillon(Base.G); + l = new MonMaillon(Base.A,l); + l = new MonMaillon(Base.T,l); + l = new MonMaillon(Base.T,l); + l = new MonMaillon(Base.C,l); + l = new MonMaillon(Base.G,l); + + MonBrin b = new MonBrin(l); + + System.out.println("l'affichage par défaut du brin ne va pas vous plaire"); + System.out.println(b.toString()); + + + System.out.println("On peut afficher en avançant"); + System.out.println("Il faut s'en inspirer pour implémenter l'interface iterator de Java.util"); + MonMaillon actuel = b.getDebut();//NB: c'est comme l ci-dessus + + while (actuel != null){ + System.out.println(actuel.getBase()); + actuel = actuel.getSuiteMaillon(); + } + } +} diff --git a/TP4/stub/0Bad/MonBrin.class b/TP4/stub/0Bad/MonBrin.class new file mode 100644 index 0000000..cd51909 Binary files /dev/null and b/TP4/stub/0Bad/MonBrin.class differ diff --git a/TP4/stub/0Bad/MonBrin.java b/TP4/stub/0Bad/MonBrin.java new file mode 100644 index 0000000..bc091ff --- /dev/null +++ b/TP4/stub/0Bad/MonBrin.java @@ -0,0 +1,28 @@ +/** + MonBrin code un brin d'ADN sous forme de liste simplement chaînée. + + Plusieurs instances de MonMaillon reliées convenablement forment une structure + simplement chaînée contenant pour chaque maillon le nom de la base. + + On n'utilise pas java.util et on recode tout. + + Cette version a un problème : la navigation n'est pas raisonnable +*/ +public class MonBrin { + + // premier maillon du brin + private MonMaillon debut; + + // Le constructeur fabrique un brin à partir du premier maillon p; + public MonBrin(MonMaillon p){ + this.debut = p; + } + + public MonMaillon getDebut(){ + return this.debut; + } + + /** et pour naviguer? + On pourrait implémenter l'interface iterator de java.util ici + **/ +} diff --git a/TP4/stub/0Bad/MonMaillon.class b/TP4/stub/0Bad/MonMaillon.class new file mode 100644 index 0000000..9de1081 Binary files /dev/null and b/TP4/stub/0Bad/MonMaillon.class differ diff --git a/TP4/stub/0Bad/MonMaillon.java b/TP4/stub/0Bad/MonMaillon.java new file mode 100644 index 0000000..1bc920f --- /dev/null +++ b/TP4/stub/0Bad/MonMaillon.java @@ -0,0 +1,40 @@ +/** + MonMaillon code un maillon d'un brin d'ADN. + plusieurs instances reliées convenablement forment une structure + simplement chaînée contenant pour chaque maillon le nom de la base. + On n'utilise pas java.util et on recode tout. + +*/ +public class MonMaillon { + + // la base portée par ce maillon + private Base base; + + // le maillon suivant dans le brin (null si fin de chaîne) + private MonMaillon suite; + + // Le constructeur de base retourne un brin à une base; + public MonMaillon(Base b){ + this.base = b; + this.suite = null; + } + + // Le constructeur évolué ajoute une base à un brin. + + public MonMaillon(Base b, MonMaillon l){ + this.base = b; + this.suite = l; + } + + public Base getBase(){ + return this.base; + } + + public MonMaillon getSuiteMaillon(){ + return this.suite; + } + +} + + + diff --git a/TP4/stub/1Iterable/Base.class b/TP4/stub/1Iterable/Base.class new file mode 100644 index 0000000..c0797ce Binary files /dev/null and b/TP4/stub/1Iterable/Base.class differ diff --git a/TP4/stub/1Iterable/Base.java b/TP4/stub/1Iterable/Base.java new file mode 100644 index 0000000..5e6a4cf --- /dev/null +++ b/TP4/stub/1Iterable/Base.java @@ -0,0 +1,4 @@ +// juste un type énuméré pour nommer les bases +public enum Base { + A,C,G,T +} diff --git a/TP4/stub/1Iterable/Exemple.class b/TP4/stub/1Iterable/Exemple.class new file mode 100644 index 0000000..ed3c5fc Binary files /dev/null and b/TP4/stub/1Iterable/Exemple.class differ diff --git a/TP4/stub/1Iterable/Exemple.java b/TP4/stub/1Iterable/Exemple.java new file mode 100644 index 0000000..8bf7349 --- /dev/null +++ b/TP4/stub/1Iterable/Exemple.java @@ -0,0 +1,35 @@ +// Fichier Exemple pour le second exercice sur l'ADN + +public class Exemple{ + public static void main(String[] args) { + // codon GCT code l'analine https://en.wikipedia.org/wiki/DNA_codon_table + // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon + + System.out.println("construction du brin GCTTAG"); + MonMaillon l = new MonMaillon(Base.G); + l = new MonMaillon(Base.A,l); + l = new MonMaillon(Base.T,l); + l = new MonMaillon(Base.T,l); + l = new MonMaillon(Base.C,l); + l = new MonMaillon(Base.G,l); + + MonBrin b = new MonBrin(l); + + System.out.println("l'affichage par défaut du brin ne va pas vous plaire"); + System.out.println(b.toString()); + + System.out.println("On peut maintenant afficher en itérant avec un while comme ceci"); + + while (b.hasNext()){ + System.out.println(b.next()); + } + + // ajouter du code ici pour gérer les questions en plus + // (simulation de plusieurs navigations successives) + + + + // (simulation de plusieurs navigations simultanées) + } + +} diff --git a/TP4/stub/1Iterable/MonBrin.class b/TP4/stub/1Iterable/MonBrin.class new file mode 100644 index 0000000..7a7918b Binary files /dev/null and b/TP4/stub/1Iterable/MonBrin.class differ diff --git a/TP4/stub/1Iterable/MonBrin.java b/TP4/stub/1Iterable/MonBrin.java new file mode 100644 index 0000000..ae826dd --- /dev/null +++ b/TP4/stub/1Iterable/MonBrin.java @@ -0,0 +1,55 @@ +import java.util.Iterator; +import java.util.NoSuchElementException; + +/** + MonBrin code un brin d'ADN sous forme de liste simplement chaînée. + + Plusieurs instances de MonMaillon reliées convenablement forment une structure + simplement chaînée contenant pour chaque maillon le nom de la base. + + On n'utilise pas java.util (pas de ArrayList, etc.) et on recode tout. + + Dans cet exercice, cette classe implémente aussi Iterator : + elle sait donc se parcourir elle-même. +*/ +public class MonBrin implements Iterator { + + // Premier maillon du brin + private MonMaillon debut; + + // Maillon courant pour la navigation (iterator) + private MonMaillon courant; + + // Le constructeur fabrique un brin à partir du premier maillon p; + public MonBrin(MonMaillon p){ + this.debut = p; + this.courant = p; // l'itération commence au début du brin + } + + public MonMaillon getDebut(){ + return this.debut; + } + + /** Méthodes de l'interface Iterator */ + + @Override + public boolean hasNext() { + return this.courant != null; + } + + @Override + public Base next() { + if (this.courant == null) { + throw new NoSuchElementException("Plus de base dans ce brin"); + } + Base valeur = this.courant.getBase(); + this.courant = this.courant.getSuiteMaillon(); + return valeur; + } + + @Override + public void remove() { + // On ne gère pas la suppression dans ce TP + throw new UnsupportedOperationException("remove() n'est pas supporté"); + } +} diff --git a/TP4/stub/1Iterable/MonMaillon.class b/TP4/stub/1Iterable/MonMaillon.class new file mode 100644 index 0000000..73ce349 Binary files /dev/null and b/TP4/stub/1Iterable/MonMaillon.class differ diff --git a/TP4/stub/1Iterable/MonMaillon.java b/TP4/stub/1Iterable/MonMaillon.java new file mode 100644 index 0000000..8dc3245 --- /dev/null +++ b/TP4/stub/1Iterable/MonMaillon.java @@ -0,0 +1,36 @@ +/** + MonMaillon code un maillon d'un brin d'ADN. + Plusieurs instances reliées convenablement forment une structure + simplement chaînée contenant pour chaque maillon le nom de la base. + On n'utilise pas java.util et on recode tout. +*/ +public class MonMaillon { + + // La base stockée dans ce maillon + private Base base; + + // Le maillon suivant dans la chaîne (null si fin du brin) + private MonMaillon suite; + + // Le constructeur de base retourne un brin à une base; + public MonMaillon(Base b){ + this.base = b; + this.suite = null; + } + + // Le constructeur évolué ajoute une base à un brin. + public MonMaillon(Base b, MonMaillon l){ + this.base = b; + this.suite = l; + } + + public Base getBase(){ + return this.base; + } + + public MonMaillon getSuiteMaillon(){ + return this.suite; + } +} + + diff --git a/TP4/stub/2Iterator/Base.class b/TP4/stub/2Iterator/Base.class new file mode 100644 index 0000000..c0797ce Binary files /dev/null and b/TP4/stub/2Iterator/Base.class differ diff --git a/TP4/stub/2Iterator/Base.java b/TP4/stub/2Iterator/Base.java new file mode 100644 index 0000000..5e6a4cf --- /dev/null +++ b/TP4/stub/2Iterator/Base.java @@ -0,0 +1,4 @@ +// juste un type énuméré pour nommer les bases +public enum Base { + A,C,G,T +} diff --git a/TP4/stub/2Iterator/Exemple.class b/TP4/stub/2Iterator/Exemple.class new file mode 100644 index 0000000..8364ec3 Binary files /dev/null and b/TP4/stub/2Iterator/Exemple.class differ diff --git a/TP4/stub/2Iterator/Exemple.java b/TP4/stub/2Iterator/Exemple.java new file mode 100644 index 0000000..b48d0a7 --- /dev/null +++ b/TP4/stub/2Iterator/Exemple.java @@ -0,0 +1,35 @@ +// Fichier Exemple pour le dernier exercice sur l'ADN (Iterable) + +public class Exemple{ + + public static void main(String[] args) { + + // codon GCT code l'analine https://en.wikipedia.org/wiki/DNA_codon_table + // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon + + System.out.println("construction du brin GCTTAG"); + MonMaillon l = new MonMaillon(Base.G); + l = new MonMaillon(Base.A,l); + l = new MonMaillon(Base.T,l); + l = new MonMaillon(Base.T,l); + l = new MonMaillon(Base.C,l); + l = new MonMaillon(Base.G,l); + + MonBrin m = new MonBrin(l); + + System.out.println("l'affichage par défaut du brin ne va pas vous plaire"); + System.out.println(m.toString()); + + System.out.println("On peut afficher en itérant avec forEach (une méthode proposée par Iterable, regardez la doc)"); + m.forEach(b -> System.out.println(b)); + + System.out.println("On a découplé la navigation de la structuration en implémentant iterable plutôt que iterator. On peut maintenant naviguer 2 fois facilement, c'est vraiment trop fort."); + m.forEach(b -> System.out.println(b)); + + System.out.println("On peut même utiliser les boucles avancées de Java 8 et notre code en devient presque pythonesque"); + for(Base b: m){ + System.out.println(b); + } + } + +} diff --git a/TP4/stub/2Iterator/MonBrin.class b/TP4/stub/2Iterator/MonBrin.class new file mode 100644 index 0000000..abc7727 Binary files /dev/null and b/TP4/stub/2Iterator/MonBrin.class differ diff --git a/TP4/stub/2Iterator/MonBrin.java b/TP4/stub/2Iterator/MonBrin.java new file mode 100644 index 0000000..e6566a8 --- /dev/null +++ b/TP4/stub/2Iterator/MonBrin.java @@ -0,0 +1,40 @@ +import java.util.Iterator; +import java.util.NoSuchElementException; +/** + MonBrin code un brin d'ADN sous forme de liste simplement chaînée. + + Plusieurs instances de MonMaillon reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base. + + On n'utilise pas java.util et on recode tout. + + Cette version est correcte : la structuration et la navigation sont dans 2 classes séparées. +La classe MonBrin implémente Iterable au sens où elle peut générer à la demande un objet Iterator. + +NB : Notez que j'implémente Iterable plutôt que Iterable qui n'était pas tout à fait propre +c'est un peu technique et c'est lié aux types génériques. + Il y a des détails ici +https://stackoverflow.com/questions/20790770/why-cant-i-assign-a-raw-type-to-a-parameterized-type-java?rq=1 +*/ +public class MonBrin implements Iterable { + + // premier maillon du brin + private MonMaillon debut; + + // Le constructeur fabrique un brin à partir du premier maillon p; + public MonBrin(MonMaillon p){ + this.debut = p; + } + + public MonMaillon getDebut(){ + return this.debut; + } + + /** Pour naviguer? + On implémente l'interface iterator de java.util ici + L'avantage c'est que c'est standard et tout le monde comprendra sans trop de mal comment la navigation fonctionne. + **/ + @Override + public Iterator iterator() { + return new MonBrinIterator(this.debut); + } +} diff --git a/TP4/stub/2Iterator/MonBrinIterator.class b/TP4/stub/2Iterator/MonBrinIterator.class new file mode 100644 index 0000000..ebaaf57 Binary files /dev/null and b/TP4/stub/2Iterator/MonBrinIterator.class differ diff --git a/TP4/stub/2Iterator/MonBrinIterator.java b/TP4/stub/2Iterator/MonBrinIterator.java new file mode 100644 index 0000000..d346a90 --- /dev/null +++ b/TP4/stub/2Iterator/MonBrinIterator.java @@ -0,0 +1,32 @@ +import java.util.Iterator; +import java.util.NoSuchElementException; + +/** +MonBrinIterator + +gère la navigation dans un Brin d'ADN +*/ +public class MonBrinIterator implements Iterator { + + // maillon courant de la navigation + private MonMaillon courant; + + public MonBrinIterator(MonMaillon m){ + this.courant = m; + } + + @Override + public boolean hasNext(){ + return this.courant != null; + } + + @Override + public Base next() { + if (this.courant == null) { + throw new NoSuchElementException("Plus de base dans ce brin"); + } + Base valeur = this.courant.getBase(); + this.courant = this.courant.getSuiteMaillon(); + return valeur; + } +} diff --git a/TP4/stub/2Iterator/MonMaillon.class b/TP4/stub/2Iterator/MonMaillon.class new file mode 100644 index 0000000..73ce349 Binary files /dev/null and b/TP4/stub/2Iterator/MonMaillon.class differ diff --git a/TP4/stub/2Iterator/MonMaillon.java b/TP4/stub/2Iterator/MonMaillon.java new file mode 100644 index 0000000..9d54454 --- /dev/null +++ b/TP4/stub/2Iterator/MonMaillon.java @@ -0,0 +1,37 @@ +/** + MonMaillon code un maillon d'un brin d'ADN. + plusieurs instances reliées convenablement forment une structure de liste simplement chaînée contenant pour chaque maillon le nom de la base. + On n'utilise pas java.util et on recode tout. + +*/ +public class MonMaillon { + + // la base stockée dans ce maillon + private Base base; + + // le maillon suivant dans la chaîne (null si fin) + private MonMaillon suite; + + // Le constructeur de base retourne un brin à une base; + public MonMaillon(Base b){ + this.base = b; + this.suite = null; + } + + // Le constructeur évolué ajoute une base à un brin. + public MonMaillon(Base b, MonMaillon l){ + this.base = b; + this.suite = l; + } + + public Base getBase(){ + return this.base; + } + + public MonMaillon getSuiteMaillon(){ + return this.suite; + } + +} + + diff --git a/TP4/stub/3IteratorDifferentInnerStructure/Base.java b/TP4/stub/3IteratorDifferentInnerStructure/Base.java new file mode 100644 index 0000000..5e6a4cf --- /dev/null +++ b/TP4/stub/3IteratorDifferentInnerStructure/Base.java @@ -0,0 +1,4 @@ +// juste un type énuméré pour nommer les bases +public enum Base { + A,C,G,T +} diff --git a/TP4/stub/3IteratorDifferentInnerStructure/Exemple.java b/TP4/stub/3IteratorDifferentInnerStructure/Exemple.java new file mode 100644 index 0000000..b4afd21 --- /dev/null +++ b/TP4/stub/3IteratorDifferentInnerStructure/Exemple.java @@ -0,0 +1,58 @@ +// Fichier Exemple pour le dernier exercice sur l'ADN (Iterable) + +public class Exemple{ + + public static void main(String[] args) { + + // codon GCT code l'analine https://en.wikipedia.org/wiki/DNA_codon_table + // codon CAT code Histidine + // codon CGT code Arginine + // codon GCC code Analine + // stop codon TAG, voir https://en.wikipedia.org/wiki/Stop_codon + + System.out.println("construction du brin CGT CAT CGT GCC CAT GCT TAG"); + MonBrin l = new MonBrin(Base.G); + l = new MonBrin(Base.A,l); + l = new MonBrin(Base.T,l); + // + l = new MonBrin(Base.T,l); + l = new MonBrin(Base.C,l); + l = new MonBrin(Base.G,l); + // + l = new MonBrin(Base.T,l); + l = new MonBrin(Base.A,l); + l = new MonBrin(Base.C,l); + // + l = new MonBrin(Base.C,l); + l = new MonBrin(Base.C,l); + l = new MonBrin(Base.G,l); + // + l = new MonBrin(Base.T,l); + l = new MonBrin(Base.G,l); + l = new MonBrin(Base.C,l); + // + l = new MonBrin(Base.T,l); + l = new MonBrin(Base.A,l); + l = new MonBrin(Base.C,l); + // + l = new MonBrin(Base.T,l); + l = new MonBrin(Base.G,l); + l = new MonBrin(Base.C,l); + // + + System.out.println("l'affichage par défaut ne va toujours pas vous plaire"); + System.out.println(l.toString()); + + System.out.println("On peut afficher en itérant avec forEach (une méthode proposée par Iterable, regardez la doc)"); + l.forEach(b -> System.out.println(b)); + + System.out.println("On a découplé la navigation de la structuration en implémentant iterable plutôt que iterator. On peut maintenant naviguer 2 fois facilement, c'est vraiment trop fort."); + l.forEach(b -> System.out.println(b)); + + System.out.println("On peut même utiliser les boucles avancées de Java 8 et notre code en devient presque pythonesque"); + for(Base b: l){ + System.out.println(b); + } + } + +} diff --git a/TP4/stub/3IteratorDifferentInnerStructure/MonBrin.java b/TP4/stub/3IteratorDifferentInnerStructure/MonBrin.java new file mode 100644 index 0000000..6cd0ad1 --- /dev/null +++ b/TP4/stub/3IteratorDifferentInnerStructure/MonBrin.java @@ -0,0 +1,83 @@ +import java.util.Iterator; +import java.util.NoSuchElementException; + +/** +MonBrin code un brin d'ADN sous forme de tableaux. Dynamiquement, la taille du tableau est augmentée en cas de besoin (la taille est initialement 3*4 elle est multipliée ensuite pour être toujours de la forme 3*2^n). +On utilise System.arraycopy et java.util.Arrays.copyOfRange pour faire ça efficacement. +voir +https://docs.oracle.com/javase/8/docs/api/java/lang/System.html#arraycopy-java.lang.Object-int-java.lang.Object-int-int- +https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html#copyOfRange-T:A-int-int- + +Cette version est correcte : la structuration et la navigation sont dans 2 classes séparées. +La classe MonBrin implémente Iterable au sens où elle peut générer à la demande un objet Iterator. + +NB : Notez que j'implémente Iterable plutôt que Iterable qui n'était pas tout à fait propre +c'est un peu technique et c'est lié aux types génériques. + Il y a des détails ici +https://stackoverflow.com/questions/20790770/why-cant-i-assign-a-raw-type-to-a-parameterized-type-java?rq=1 +*/ + +public class MonBrin implements Iterable { + + /** + C'est le constructeur de base (pun intended) qui construit un brin à une base + + @param b : la base + + Ici je pourrais mettre un commentaire plus long sur le fonctionement détaillé de mon super constructeur. + + */ + public MonBrin(Base b){ + + } + + /** + C'est le constructeur évolué qui construit un brin en ajoutant la base donnée en argument devant le brin donné en argument. + + @param b : la base qui va aller devant + @param l : le brin qui sera à la suite + + NB. Ce constructeur est un peu obsolète avec la nouvelle structure interne. + On devrait en ajouter un qui prend en paramètre un tableau de bases. + */ + public MonBrin(Base b, MonBrin l){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public Base getBase(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public int length(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public int limit(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public int capacity(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public Base getBase(int i){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + public Base[] getBases(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + /** Pour naviguer? + On implémente l'interface iterator de java.util ici + L'avantage c'est que c'est standard et tout le monde comprendra sans trop de mal comment la navigation fonctionne. + **/ + @Override + public Iterator iterator() { + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + +} + + diff --git a/TP4/stub/3IteratorDifferentInnerStructure/MonBrinIterator.java b/TP4/stub/3IteratorDifferentInnerStructure/MonBrinIterator.java new file mode 100644 index 0000000..363d355 --- /dev/null +++ b/TP4/stub/3IteratorDifferentInnerStructure/MonBrinIterator.java @@ -0,0 +1,33 @@ +import java.util.Iterator; +import java.util.NoSuchElementException; + +/** +MonBrinIterator + +gère la navigation dans un Brin d'ADN + +*/ +public class MonBrinIterator implements Iterator { + + //Le constructeur de base retourne un brin à une base; + public MonBrinIterator(MonBrin brin){ + } + + /** Pour naviguer? + On implémente l'interface iterable de java.util ici + L'avantage c'est que c'est standard et tout le monde comprendra sans trop de mal comment la navigation fonctionne. + **/ + + @Override + public boolean hasNext(){ + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + + @Override + public Base next() { + throw new UnsupportedOperationException("cette méthode n'est pas implémentée"); + } + +} + + diff --git a/TP4/stub/explication.txt b/TP4/stub/explication.txt new file mode 100644 index 0000000..9254e46 --- /dev/null +++ b/TP4/stub/explication.txt @@ -0,0 +1,20 @@ +Les biologistes sont des gens étranges pour lesquels les string n'ont que 4 lettres : A,C,G ou T. +Ils ne connaissent pas les String, ils parlent d'ADN. + + +Le Brin est une succession de Maillons. +Il suffit de connaître le premier maillon pour définir un brin d'ADN. + + +----------+ + | maillon | + | | _____ next __> autre Maillon + | | + +----+-----+ + | + | val + \|/ + +----------+ + | Base | + | A | + | | + +----+-----+