EXAMEN 2019

/* examen 2019 PRG1 Decembre 2019 */

/*
Exercice 1
*/
public class PostcardCollection extends Table<String,EditorCatalog>{

/**
* @param editor nom de l'éditeur
* @param id identifiant de carte postale
* @return true si la carte postale ayant identifiant id de l'éditeur
* editor est présente dans this, false sinon
*/

public boolean hasPostcardById(String editor, Integer id){

/*Il faut remarquer que le param editor est en faite une clé dans This
et on sait tous que si on a la clé pas besoin de faire un iterateur*/
EditorCatalog ec = this.getValue(editor);

// N.B. lorsqu'une clé est passé en paramètre il faut toujours tester si

//sa valeur n'est pas null
if(ec!=null){
/*Il faut remarquer que le param id est en faite une clé dans ec
et on sait tous que si on a la clé pas besoin de faire un iterateur*/
Postcard p = ec.getValue(id);
// N.B. lorsqu'une clé est passé en paramètre il faut toujours tester
si
//sa valeur n'est pas null
if(p!=null){
//si la valeur n'est pas null return vrai
return true;
}else{//sinon faux
return false;
}
}else{
return;
}
}

/**
* Supprimer de this toutes les cartes postales de l'éditeur
* editor représentant la commune de code commune
* @param commune code de commune
* @param editor nom de l'éditeur

*/
public void sellPostcards(String editor, Integer commune){
/*Il faut remarquer que le param editor est en faite une clé dans This
et on sait tous que si on a la clé pas besoin de faire un iterateur*/
EditorCatalog ec = this.getValue(editor);
if(ec!=null){
 Iterator<Integer> it = ec.iterator();
while(it.hasNext()){
Integer id= it.next();
Postcard p = ec.getValue(id);
if(p.commune==commune){
ec.removeValue(id);
}
if(ec==null){
this.removeValue(editor);
}
}
}
}

/**

* @return nombre de commune différentes présente dans this

*
* @post this reste inchangé
*/
public int numberOfcommunes(){
Set<Integer> set = new Set<>();
Iterator<String> it_1 = this.iterator();
while(it.hasNext()){
String editor= it_1.next();
EditorCatalog ec = this.getValue(editor);

Iterator<Integer> it_2 =ec.iterator();

while(it_2.hasNext()){
Integer id= it_2.next();
Postcard p = ec.getValue(id);

set.add(p.commune);

}
}
return set.size();
}

/**
* @param pc2 deuxième catalogue de cartes postales
* @post this et pc2 restent inchangés
* @return ensemble des éditeurs qui ont au moins une même carte
* postale dans this et pc2 (on suppose que deux cartes
* sont identiques si elles ont le même éditeur et le même
* numéro)
*
* N.B. il s'agit de la classe Set vue en cours.
*/
public Set<String> inBothCatalogs(PostcardCollection pc2){
Set<String> set_editor = new Set<>();
Iterator<String> it_1 = pc2.iterator();
while(it_1.hasNext()){
 String editor = it_1.next();
EditorCatalog ec1 = this.getValue(editor);
EditorCatalog ec2 = pc2.iterator();
if(ec1!=null){
Iterator<Integer> it_2 = ec2.iterator();
while(it_2.hasNext()){
Integer id = it.next();

Postcard p1 = ec1.getValue(id);
Postcard p2 = ec2.getValue(id);
if(p1!=null){
if(p1.editor.equals(p2.editor)){
set_editor.add(p2.editor);
}
}
}
}
}
}

/**
* @return la table dont les clefs sont les numéros de communes et
* les valeurs un ensemble de tripletd <editor,postcardID,
* legend> tels que le quadruplet <editor,postcardID,
* legend, commune> appartient à this
* @post this reste inchangé
*
* N.B. il s'agit de la classe Set vue en cours.
*/
public Table<Integer,Set<Triplet>> createTableByCommune(){

Table<Integer,Set<Triplet>> t1 = new Table<>();

Iterator<String> it1 = this.iterator();
while(it1.hasNext()){
String editor = it.next();
EditorCatalog ec = this.getValue(editor);
Iterator<Integer> it2 = ec.iterateur();
while(it2.hasNext()){
Integer id= it.next();
Postcard p = ec.getValue(id);
Triplet tp1 = new Triplet(p.editor,p.legend,id);
if(tp1.contains(p.commune)){
tp1.getValue(id).add(tp1);
}else{
Set<Triplet> set = new Set<>();
set.add(tp1);
t1.addValue(p.commune,set);
}
}
}
}
}
/*
Exercice 2
*/
public class LanguageCatalog extends BinaryTree<Language>{
/**
* @param language
* @return true si language est présent dans this, false sinon
*/
/*
x.compareTo(y) == -1 si x < y
... == 0 si x = y
... == 1 si x > y
*/
public boolean search(Language language){
// on declare l'iterateur
Iterator<Language> it = this.iterator();
while(!it.isEmpty()){
if(it.getValue().compareTo(language) == 0){
return true;
}else if(it.getValue().compareTo(language) == -1){
it.goRigth();
}else{
it.goLeft();
}
}
return false;
}

/**
* Afficher les langages créés en année year, dans l’ordre préfixe.
* @param year
*/
public void printByYear(int year){
// on declare l'iterateur
Iterator<Language> it = this.iterator();
printByYearAux(it, year);
}

private void printByYearAux(Iterator<Language> it, int year){

if(!it.isEmpty()){
// je fais mon traitement pour le parcours prefix: pour ce cas on est
là
if(it.getValue().creation == year){
System.out.println(it.getValue());
}
it.goLeft();
printByYearAux(it, year);
// je fais mon traitement pour le parcours infix
it.goUp();

it.goRigth();
printByYearAux(it, year);
 // je fais mon traitement pour le parcours postfix
it.goUp();
}

}
/**
* @pre Les attributs leftHeight et total ne sont pas remplis
* dans this.
* @post Tous les attributs leftHeight et total de this sont remplis.
*/
public void fillAllFields() {
Iterator<Language> it = this.iterator();
fillAux(it);
}

private static Pair fillAux(Iterator<Language> it){

Pair pair = new Pair();
if(!it.isEmpty()){
it.goLeft();
Pair leftPair = fillAux(it);
it.goUp();
// traitement
if(pair.heigth == 0){
it.getValue().leftHeight = -1;
}else{
it.getValue().leftHeight += 1;
}
pair.height = it.getValue().leftHeight;
// fin du traitement
it.goRight();
Pair rightPair = fillAux(it);
it.goUp();
//total gauche + total droit + lui-meme
pair.total = leftPair.total + rightPair.total + 1;
}

return pair;
}

/**
* Pour chaque branche (chemin de la racine à une feuille),
* afficher la suite des noms de langages parcourus (commençant
* par la feuille et se terminant par la racine). L’ordre entre les
* branches n’est pas important.
*
* Dans l’exemple cela pourrait donner :
*
* Basic Ada C Eiffel
* Cobol C Eiffel
* Fortran Groovy Eiffel
* Haskell Java Kotlin Groovy Eiffel
*/
public void printPaths(){
 Iterator<Language> it = this.iterator();
String path = "";
printPathsAux(it, path);
}

private void printPathsAux(Iterator<Language> it, String path){

if(!it.isEmpty()){
// si Prefix (traitement): System.out.println(it.getValue());
path = it.getValue().name + path;
it.goLeft();
printPathsAux(it, path);
it.goUp();

it.goRight();
printPathsAux(it, path);
it.goUp();
System.out.println(path);
}

/* Remarque Parcours
// si Prefix (traitement): System.out.println(it.getValue());
it.goLeft();
parcoursRecurs(it);
it.goUp();
// si Infix (traitement): System.out.println(it.getValue());
it.goRight();
parcoursRecurs(it);
it.goUp();
// si Postfix (traitement): System.out.println(it.getValue());
*/

}
EXAMEN 2020

/*========= Exam decembre 2020 =================*/

/*Exercice1*/

public class PostcardCollection extends BinaryTree<Postcard>{

// Question 1
/**
* @param postcardID identifiant de carte postale
* @return true si une carte d'identifiant postcardID est
* présente dans this, false sinon
*
*/
public boolean findPostCard(int postcardID){
Iterator<Postcard> it = this.iterator();
while(!it.isEmpty()){
if(it.getValue().postcardID == postcardID){
// écrire ici le traitement à faire si on trouve l'élément
return true;
}else if(it.getValue().postcardID < postcardID){
it.goRight();
}else{
it.goLeft();
}
}
return false;
}
/**
* Stocker l'ordre de parcours postfixe de l'arbre this dans le
* champ extraField.
* Indication : on peut créer un attribut d'instance supplémentaire
* dans la classe PostcardCollection.
*
*/

// on considere la variable ci-dessous declaree dans la classe (variable

d'instance)
int value = 0;

// Question 2
public void addPostOrderNumbers(){
Iterator<Postcard> it = this.iterator();
addPostOrderNumbersAux(it);
}

// on a besoin d'un iterator pour parcourir l'abre, d'ou it en parametre

private void addPostOrderNumbersAux(Iterator<Postcard> it){
if(!it.isEmpty()){
it.goLeft();
// aller dans le sous-arbre gauche
addPostOrderNumbersAux(it);
 // remoter au pere
it.goUp();
// aller dans le sous-arbre droit
it.goRight();
// sous arbre
addPostOrderNumbersAux(it);
it.goUp();
// traiter le noeud selon ce qui est demandé dans le sujet
it.getValue().extraField = value;
value = value+1;
}
}

/**
* @pre !this.isEmpty()
* @return la légende la plus longue parmis les cartes postales
* presentes dans this
* (choisir une d'elles dans le cas d'ex-aequo)
*/

// Question 3
public String longestLegend(){
Iterator<Postcard> it = this.iterator();
String longestLegend = "";
return longestLegendAux(it, longestLegend);
}

// on a besoin d'un iterator pour parcourir l'abre, d'ou it en parametre

public String longestLegendAux(Iterator<Postcard> it, String longestLegend){
if(!it.isEmpty()){
it.goLeft();
// aller dans le sous-arbre gauche
longestLegendAux(it);
it.goUp();
// traiter le noeud selon ce qui est demandé dans le sujet
if(longestLegend.length < it.getValue().legend.length){
longestLegend = it.getValue().legend;
}
// aller dans le sous-arbre droit
it.goRight();
// sous arbre
longestLegendAux(it);
it.goUp();
}
return longestLegend;
}

/**
* @return true si pour chaque noeud la difference entre les nombres
* de noeuds des deux sous-arbres est inférieure ou égales à 1,
* false sinon
*/
 // Question 4
public boolean isNodeBalnacedTree(){
Iterator<Integer> it = this.iterator();
return isNodeBalnacedTreeAux(it);
}

// on a besoin d'un iterator pour parcourir l'abre, d'ou it en parametre

public boolean isNodeBalnacedTreeAux(Iterator<Integer> it){
int nbreFilsGauche = 0, nbreFilsDroit = 0;
if(!it.isEmpty()){
it.goLeft();
// aller dans le sous-arbre gauche
boolean isNodeBalnacedLeft = isNodeBalnacedTreeAux(it); // true
// remoter au pere
it.goUp();
if(isNodeBalnacedLeft){
nbreFilsGauche++;
}
// aller dans le sous-arbre droit
it.goRight();
// sous arbre
boolean isNodeBalnacedRight = isNodeBalnacedTreeAux(it); // true
it.goUp();
if(isNodeBalnacedRight){
nbreFilsDroit++;
}
// traiter le noeud selon ce qui est demandé dans le sujet
int difference = nbreFilsGauche - nbreFilsDroit;
if(difference <= 1){
return true;
}
// return (nbreFilsGauche - nbreFilsDroit) <= 1;
}

return false;
}
}

/*Exercice2*/
public class Corpus extends Table<String,Journal>{

/** Question1

* @param journalName nom du journal scientifique

* @param articleID identifiant d'article dans journalName
* @return auteur de l'article s'il existe dans this
* null sinon
*
*/

public String returnAuthor(String journalName, int articleID){

Journal j = this.getValue(journalName);
 if(j!=null){
Article a = j.getValue(articleID);
if(a!=null){
return a.author;
}else{
return null;
}
}else{
return;
}
}
/**Question2

* Afficher à l'écran tous les auteurs qui ont publié dans

* journalName.
* (Bien sûr chaque auteur ne doit être affiché qu'une fois.)
*
* @param journalName nom du journal
*/
public void printAuthorList(String journalName){
Set<String> set = new Set<>();
Journal j = this.getValue(journalName);
if(j!=null){
Iterator<Integer> it = j.iterator();
while(it.hasNext()){
Integer articleID = it.next();
Article a = j.getValue(articleID);

set.add(a.author);
}
}
for( String author: set){
System.out.println(author);
}
}

/**Question3

* Supprimer tous les articles écrits par author, condamné pour

* fraude scientifique.
*
* @param author nom de l'auteur
*/
public void removeAuthor(String author){
Iterator<String> it1 = this.iterator();
while(it1.hasNext()){
String journalName = it.next();
Journal j = this.getValue(journalName);
Iterator<Integer> it2 = j.iterator();
while(it2.hasNext()){
Integer articleID = it.next();
Article a = j.getValue(articleID);
if(a.author.equals(author)){
 j.removeValue(articleID);
}
if(j==null){
this.removeValue(journalName);
}
}
}
}

/** Question 4

* Ajouter les articles de corpus dans this.

*
* @param corpus deuxième corpus
* @throws Exception dans le cas où les 2 corpus ont des
* articles distincts dans le même
* journal sous le même ID
*/

public void mergeCorpora(Corpus corpus) throws Exception{

Iterator<String> it1 = corpus.iterator();
while(it1.hasNext()){
String journalName = it1.next();

//ici on test si la clé journalName recupéré dans corpus est

présente dans this
Journal j1 = this.getValue(journalName);
// on récupère la valeur de la clé journalName dans corpus
Journal j2 = corpus.getValue(journalName);
if(j1==null){
this.addValue(journalName,j2);
}else{
Iterator<Integer> it2 = j2.iterator();
while(it2.hasNext()){

Integer articleID = it2.next();

//ici on test si la clé articleID recupéré dans le journal

j2 de corpus
//est présente dans le journal j1 de this
Article a1 = j1.getValue(articleID);

// on récupère la valeur de la clé articleID dans le

journal j2 de corpus
Article a2 = j2.getValue(articleID);

/*Si a1 est null alors l'article n'existe pas dans le

journal de this il
faut donc l'ajouter
*/
if(a1==null){
j1.addValue(articleID,a2);
}else if(!a1.equals(a2)){
 /*ici on gère le cas ou l'article existe dans le
journal de this mais
est différent de celui du journal de corpus alors
comme l'énoncé le
stipule on lève une exception*/

throws new Exception();

}
}
}
}
}

/** Question 5

* @param author1 premier auteur

* @param author2 second auteur
* @return l'auteur entre author1 et author2 qui a publié dans moins
* de journaux différents, et n'importe lequel des deux dans
* le cas d'égalité
*/
public String lessWidelyPublishingAuthor(String author1, String author2){

//set1 pour ranger les journaux de l'auteur1

Set<String> set1= new Set<>();
//set1 pour ranger les journaux de l'auteur2
Set<String> set2= new Set<>();

Iterator<String> it1 = this.iterator();

while(it.hasNext()){
String journalName = it.next();
Journal j = this.getValue(journalName);
Iterator<Integer> it2 = j.iterator();
while(it2.hasNext()){
int articleID = it2.next();
Article a = j.getValue(articleID);

if(a.author.equals(author1){
set1.add(journalName);
}
if(a.author.equals(author2){
set2.add(journalName);
}
}
}
if(set1.size()>set2.size()){
return author2;
}else{
return author1;
}
}

}
EXAMEN 2018
/*=========================== Examen 2018 =======================*/

/*Exercice1*/
public class BookCollection extends Table<String,AuthorBooks>{

public boolean hasBook(String author, String isbn){

AuthorBooks ab = this.getValue(author);
if(ab!=null){
Book b = ab.getValue(isbn);
if(b!=null){
return true;
}else{
return false;
}
}else{
return;
}
}

public void addBook(String author, String isbn, String title, String language){
Book b = new Book(title,language);
AuthorBooks ab = this.getValue(author);
if(ab!=null){
ab.addValue(isbn,b);
}else{
this.addValue(author,ab.addValue(isbn,b));
}
}

public String findAuthorByISBN(String isbn){

Iterator<String> it = this.iterator();
while(it.hasNext()){
String author = it.next();
AuthorBooks ab = this.getValue(author);
if(ab.contains(isbn)){
Book b = ab.getValue(isbn);
if(b!=null){
return b.author;
}
}
}
return null;
}

public String removeBooks(String isbn){

Iterator<String> it = this.iterator();
while(it.hasNext()){
String author = it.next();
AuthorBooks ab = this.getValue(author);
Iterator<String> it2 = ab.iterator();
while(it2.hasNext()){
 String isbn = it.next();
Book b = ab.getValue(isbn);
if(b.language.equals(language)){
ab.removeValue(isbn);
}
if(ab==null){
this.removeValue(author)
}
}
}
}

public String morePresentLanguage(String language1,String language2){

Set<String> set_l1 = new Set<>();
Set<String> set_l2 = new Set<>();

Iterator <String> it1 = this.iterator();

while(it1.hasNext()){
String author = it1.next();
AuthorBooks ab = this.getValue(author);
Iterator<String> it2= ab.iterator();
while(it2.hasNext()){
String isbn = it.next();
Book b = ab.getValue(isbn);
if(b.language.equals(language1)){
set_l1.add(b.author);
}
if(b.language.equals(language2)){
set_l2.add(b.author);
}
}
}
if(set_l1.size()>set_l2.size()){
return language1;
}
if(set_l1.size()<set_l2.size()){
return language2;
}
}
}

/*Exercice2*/

public class BinaryNumberSet extends BinaryTree<BinaryNumber>{

public void printValue(){

Iterator<BinaryNumber> it = this.iterator();
printValueAux(it);
}
private void printValueAux(Iterator<BinaryNumber> it){
if(!it.isEmpty()){

it.goLeft();
 printValueAux(it);
it.goUp();
it.goRight();
printValueAux(it);
it.goUp();

System.out.println(it.getValue().getNumber());
}
}

public boolean isPresent(BinaryNumber number){

Iterator<BinaryNumber> it = this.iterator();
while(!it.isEmpty()){
if(it.getValue().getNumber().compareTo(number)==0){
return true;
}else if(it.getValue().getNumber().compareTo(number)==-1){
it.goRight();
}else{
it.goLeft();
}
}
return false;
}

public void addValue(BinaryNumber number){

}
}