IFT1025-A2010 Examen Final Programmation 2 Date:16 décembre

IFT1025-A2010
Examen Final
Programmation 2
Date:16 décembre, 12:30-15:30
Guy Lapalme
(60) 1. Vous devez écrire une application Java qui va fournir une liste triée des couples de
mots successifs (bigrammes) d’un fichier avec leur fréquence (c’est-à-dire leur nombre
d’occurrences). Par exemple, soit le fichier suivant
Vive le vent, vive le vent
Vive le vent d’hiver
Qui s’en va sifflant, soufflant
Dans les grands sapins verts...
Oh ! Vive le temps, vive le temps
Vive le temps d’hiver
Boule de neige et jour de l’an
Et bonne année grand-mère...
La liste des bigrammes qui apparaissent plus d’une fois sera la suivante:
(le,temps):3
(le,vent):3
(temps,vive):2
(vent,vive):2
(vive,le):6
Pour y arriver, vous devez suivre les étapes suivantes:
(10)
(a) Implantez une méthode getMots qui reçoit en paramètre le nom d’un fichier et qui
retourne un liste des mots (de type List<String>) dans ce fichier. Les méthodes
de traitement de fichier sont rappelées à la page 6 et l’interface List à la page 4.
(20)
(b) Soit la classe générique Pair suivante (identique à celle présentée en classe)
class Pair<T,S>{
private T first;
private S second;
public Pair(T first, S second){
this.first=first;
this.second=second;
}
public T getFirst(){return first;}
public S getSecond(){return second;}
public String toString(){
return "("+first+","+second+")";
}
}
IFT1025-A2010
Page 2
Écrivez la classe Bigramme comme sous-classe de Pair pour conserver deux String
correspondant aux deux mots du bigramme. Cette sous-classe devrait implanter
l’interface Comparable (sa définition est rappelée en page 4). Un bigramme est trié
d’abord sur son premier mot et ensuite sur son deuxième en utilisant l’ordre naturel
des String.
(10)
(c) Dites quelle structure de données du FrameWork des Collections de Java vous
choisiriez pour conserver les bigrammes et leur fréquence.Justifiez votre choix.
(10)
(d) Implantez une méthode getBigrammes qui reçoit la liste des mots du fichier retournée en (a) et qui calcule les fréquences des bigrammes à l’aide de la structure
de donnée que vous aurez choisie en (c). Cette méthode retourne la structure remplie.
(10)
(e) Écrivez la méthode imprimerBigrammes qui écrit sur System.out les bigrammes et
leur fréquence calculés en (d) lorsque lorsque leur fréquence est plus grande que 1.
Voir l’exemple du résultat attendu au début de l’énoncé de ce numéro.
(30) 2. Implantez une classe générique FIFO (first-in, first-out) qui est une structure qui permet
de conserver des éléments d’un type quelconque dans une file d’attente selon l’ordre
premier arrivé, premier servi. Cette classe comprend les méthodes suivantes:
entrer qui ajoute l’élément donné en paramètre à la fin de la file et retourne la file
modifiée;
sortir qui retire un élément au début de la file et le retourne en résultat;
nb qui indique le nombre d’éléments dans la file.
(10)
(a) Quelle structure de données du Framework des Collections vous semble la plus
appropriée pour implanter cette classe ? justifiez votre réponse.
(20)
(b) Écrivez le code Java pour implanter cette classe en utilisant la structure de données
que vous avez choisie en (a). Donnez le code complet de la classe: c’est-à-dire les
trois méthodes entrer, sortir et nb et aussi celui du constructeur et de la méthode
toString() qui retourne dans une chaı̂ne une représentation des éléments dans la
file.
IFT1025-A2010
Page 3
(10) 3. Dans la définition de BSTNode, rappelée à la page 7, ajoutez la méthode
public List<E> sansDescendants()
qui retourne une liste de tous les noeuds n’ayant aucun noeud enfant.
(2) 4. Question bonus. Quelle ligne faudrait-il insérer à la place du commentaire dans ce
programme Java pour qu’il devienne syntaxiquement correct et qu’il imprime Bonjour
les amis.
public class BrowserTest {
public static void main(String[] args) {
// compléter ici...
if(i!=i+0)
System.out.println("Bonjour les amis");
}
}
Cet examen comporte 3 questions pour un total de 100 points.
Bonne chance
IFT1025-A2010
Rappel d’éléments du Collection Framework de Java
public interface Collection<E> extends Iterable<E>{
// Opérations de base
int size();
boolean isEmpty();
boolean contains(Object element);
boolean add(E element);
boolean remove(Object element);
Iterator<E> iterator();
// Opérations de groupe
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean removeAll(Collection<?> c);
boolean retainAll(Collection<?> c);
void clear();
}
public interface Iterator<E> {
boolean hasNext();
<E> next();
void remove();
}
public interface Comparable<T> {
public int compareTo(T o);
}
public interface Comparator<T> {
public int compare(T o1, T o2);
}
public interface List<E> extends Collection<E> {
// accès par position
E get(int index);
E set(int index, E element);
void add(int index, E element);
E remove(int index);
boolean addAll(int index, Collection <? extends <E>>);
// recherche
int indexOf(Object o);
int lastIndexOf(Object o);
//Exemples de création
//List<String> l = new ArrayList<String>();
//List<Integer> l = new LinkedList<Integer>();
}
Page 4
IFT1025-A2010
public
//
//
//
//
}
Page 5
interface Set<E> extends Collection<E>{
aucune nouvelle méthode
mais s’assure que tous les éléments sont distincts
Exemple de création
Set<String> s = new HashSet<String>();
public interface Map<K,V> {
// Opérations de base
V put(K key, V value);
V get(K key);
V remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
// Opérations de groupe
void putAll(Map<? Extends K, ? extends V> m);
void clear();
// Vues comme des Collections
public Set<K> keySet();
public Collection<V> values();
public Set<Map.Entry<K,V>> entrySet();
// Interface pour les entrées de la table (entrySet)
//
on la désigne par Map.Entry
public interface Entry<K,V> {
K getKey();
V getValue();
V setValue(V value);
}
//Création
//Map<String,Integer> m = new HashMap<String,Integer>();
//Map<String,Integer> m = new LinkedHashMap<String,Integer>();
}
public interface
// vue comme
SortedSet<E>
SortedSet<E>
SortedSet<E>
SortedSet<E> extends Set<E> {
sous-ensemble
subSet(Object fromElement, Object toElement);
headSet(Object toElement);
tailSet(Object fromElement);
// points extr^
emes
E first();
E last();
IFT1025-A2010
Page 6
// accès au comparateur
Comparator<? super E> comparator();
//Création
//SortedSet<String> ss = new TreeSet<String>();
}
public interface SortedMap<K,V> extends Map<K,V> {
// vue comme sous-table
SortedMap<K,V> subMap(K fromKey, K toKey);
SortedMap<K,V> headMap(K toKey);
SortedMap<K,V> tailMap(K fromKey);
// accès aux clés extr^
emes
K firstKey();
K lastKey();
// accès au comparateur
Comparator<? super K> comparator();
//Création
//SortedMap<String,Integer> sm = new TreeMap<String,Integer>();
}
Rappel sur la lecture de fichiers
Entrées-sorties BufferedReader in = new BufferedReader(new FileReader(fileName));
BufferedReader contient la méthode readLine() qui retourne une ligne comme un String
ou null lorsqu’on est à la fin du fichier.
Tokenization Scanner sc = new Scanner(l);
Scanner contient les méthodes
hasNext() qui retourne true s’il reste des tokens à traiter
next() qui retourne le prochain token comme une String (vous pouvez supposer ici que
next() élimine les ponctuations et que la chaı̂ne retournée ne contient que les caractères
du mot en minuscule)
Exceptions FileReader peut lever FileNotFoundException et BufferedReader peut lever IOException
qui doivent être traitées en indiquant le nom du fichier où s’est produit l’exception sur
System.err.
IFT1025-A2010
Rappel de certains éléments de la classe BSTNode
public class BSTNode <E extends Comparable<E>> {
protected E element;
protected BSTNode<E> left, right;
public BSTNode (E elem) {
// Construct a BST node with element elem and no children.
this.element = elem;
this.left = null;
this.right = null;
}
public void insert (E elem) {
// Insert the element elem in this BST if not already there.
int direction = elem.compareTo(element);
if (direction<0)
if(left==null)
left = new BSTNode<E>(elem);
else
left.insert(elem);
else if (direction>0)
if (right==null)
right = new BSTNode<E>(elem);
else
right.insert(elem);
}
}
Page 7