Vous êtes sur la page 1sur 6

Licence Informatique troisième année

GROUPE DE TD :

Contrôle continu n°1


MLL5U2O
Durée 0H45

Epreuve sans document

23/10/18 12H25

Ne pas consulter le sujet


avant le signal donné
par le responsable de l'épreuve

Les stylos doivent être posés à la fin du temps réglementaire.

Aucune sortie autorisée pendant cette épreuve.

23/10/18
Question 1 (2 point) (cocher les cases correspondant à votre réponse)
bonne réponse : +0,25 point mauvaise réponse : -0,25 point pas de réponse : 0

VRAI FAUX
1. Object string=new String() ; V
La valeur de (string instanceof Object) est égale à true.
2. String string=new String() ; V
La valeur de (string instanceof Object) est égale à true.
3. Toutes les classes d’exceptions susceptibles d’être lancées dans une F
fonction doivent être signalées dans l’entête avec le mot clé throws
4. Une exception lancée dans une méthode doit être attrapée dans cette F
méthode (sinon cela provoque l’arrêt du programme)
5. java.io.InputStream est une classe abstraite V
6. Une classe interne peut être définie à l’intérieur d’une méthode V
7. Maven a pour objectif principal d’optimiser le temps d’exécution des F
programmes
8. Dans Maven, la phase compile fait partie du cycle de vie par défaut V

Question 2 (2 point)

Soit la classe suivante :

On considère le "jeu" suivant :


Le programme demande des entiers à l'utilisateur. La contrainte est que l'utili-
sateur doit donner des entiers compris entre deux bornes. Le score obtenu au jeu
est le nombre d’entiers fournis compris entre ces deux bornes.
Exemple : si l'on attend 5 nombres compris entre 50 et 100 et que l'utilisateur
répond 63 56 69 15 87, cela affichera 4 car parmi les 5 nombres proposés, seuls
4 sont compris entre 50 et 100

*/
public class ExoExcep {
public static void verifierIntervalle(int entier,int min,int max) {
if (entier<min||entier>max)
throw new RuntimeException("on souhaite un entier entre "+
min+" et "+max+ " trouvé :"+entier);
}

public static int jeuTresSimplePourLesTresJeunes


(Terminal term,int min,int max,int nbTests)
{
int nbSucces=0;
for (int i=1;i<=nbTests;i++) {
verifierIntervalle(term.readInt("un entier entre "+min+" et "+max),min,max);
nbSucces++;
}
return nbSucces;
}

public static void main(String[] args) {


int nbTests=5;

23/10/18
int nbSucces=jeuTresSimplePourLesTresJeunes(new Terminal("Jeu très
simple",400,400),50,100,nbTests);
System.out.println("Nombre de succés :"+nbSucces);
}
}

a) Tel que le programme est écrit ci-dessous, il ne fonctionnera pas correc-


tement. Pourquoi ?

Si la méthode verifierIntervalle lance une exception, elle n’est pas catchée


donc le programme s’arrête

b) modifier la fonction "jeuTresSimplePourLesTresJeunes" de telle sorte que le


jeu fonctionne comme attendu.

L’instruction de la boucle for est modifiée comme suit :


{
try {
verifierIntervalle(term.readInt("un entier entre "+min+" et "+max),min,max);
}
catch (RuntimeException exp) {term.println("Mauvaise réponse");}

nbSucces++;
}

c) donner ci-dessous le commentaire javadoc de la fonction "jeuTresSimplePour-


LesTresJeunes"

/**
* demande plusieurs entiers à l'utilisateur et rend le nombre de fois que ces nombres sont
compris entre une borme min et une borme max
* @param term le terminal utilisé pour demander les entiers
* @param min la borne min
* @param max la borme max
* @param nbTests le nombre d'entiers à demander
* @return le nombre d'entiers forunis compris entre min (inclus) et max (inclus)
*/

23/10/18
Question 3 (2 points)
On considère le programme suivant. Compléter la définition de la méthode getUnEltSpecifique.

public class ExoMap {


public static String getUnEltSpecifique(Collection<String> col-
lec1,Collection<String> collec2) {
Iterator<String> itCollec1=collec1.iterator();
String chaineSpecifique=null;
while (itList1.hasNext()&&chaineSpecifique==null) {
String eltList1 = itList1.next();
if (! list2.contains(eltList1))
chaineSpecifique=eltList1;
}
return chaineSpecifique;

}
/**
* rend une string qui est une clef d'une première map mais pas de la
deuxieme map
* @param map1 la premiere map
* @param map2 la deuxieme map
* @return une string qui est une clef de map1 mais pas de map2, null si
toutes les clefs de map1 sont des clefs de map2
*/
public static String getUneClefSpecifique
(Map<String,String> map1,Map<String,String> map2)
{
return getUnEltSpecifique(map1.keySet(),map2.keySet());
}
public static void main(String[] args) {
Map<String,String> map1=new HashMap<>();
map1.put("k1","v1");
map1.put("k2","v2");
map1.put("k3","v3");
Map<String,String> map2=new HashMap<>();
map2.put("k1","w1");
map2.put("k2","w2");
map2.put("k3","v3");
map2.put("k4","v4");
Map<String,String> map3=new HashMap<>();
map3.put("k1","w1");
map3.put("k3","v3");
System.out.print(getUneClefSpecifique(map1,map2)+" ");
System.out.print(getUneClefSpecifique(map1,map3)+" ");
System.out.print(getUneClefSpecifique(map2,map3)+" ");
System.out.print(getUneClefSpecifique(map3,map2)+" ");
System.out.println(getUneClefSpecifique(map2,map1));
// l'execution de la méthode main produit l'affichage suivant :
// null k2 k2 null k4
}
}

Question 4 (2 points)

Quel est l’affichage produit par l’exécution de la fonction main du programme ci-dessous ?

NOOOOONNNN

23/10/18
public class ParametreAffectation {
public static void test(List<String>l3) {
l3.add("1");
l3=null;
List<String> l2= null;
}
public static void main(String[] args) {
List<String> l1 = new ArrayList<>();
List<String> l2 = new ArrayList<>();
List<String> l3 = new ArrayList<>();
String[]tab= {"4","8","2","9"};
for (String s: tab) {
l1.add(s);
l2.add(s);
l3.add(s);
}
f(l1,l2);
l3=l2;
f(l2,l3);
l2.add("5");
f(l2,l3);
l2=l1;
f(l1,l3);
test(l3);
f(l2,l3);
System.out.println();
}

public static void f(List<String> l1,List<String> l2) {


System.out.print(b2s(l1==l2)+b2s(l1.equals(l2)));
}

private static String b2s(boolean bool) {


return bool?"O":"N";
}
}
Question 5 (2 points)
Compléter le programme suivant :
/**
* rend le plus petit des entiers compris dans une liste de liste d'entiers
* @param listDeList la liste des listes d'entiers
* @return le plus petit des entiers compris dans une liste de liste d'entiers
* @throws RuntimeException si toutes les listes d'entiers sont vides
*/
public static Integer lePlusPetit(List<List<Integer>> listDeList) {
Integer plusPetit=null;
for (List<Integer> list : listDeList) {
Integer plusPetitList=getMinimum(list);
if (plusPetit==null)
plusPetit=plusPetitList;
else if (plusPetitList!=null&&plusPetitList.compareTo(plusPetit)<0)
plusPetit=plusPetitList;
}
if (plusPetit==null)
throw new RuntimeException("Listes toutes vides");
return plusPetit;

23/10/18
}

/**
* rend le plus petit élément d'une liste d'entier, null si la liste est
vide
* @param list la liste d'entiers
* @return le plus petit élément de la liste list, null si la liste list
est vide
*/
private static Integer getMinimum(List<Integer> list) {
if (list.isEmpty())
return null;
else {
Integer plusPetit=list.get(0);
for(int i=1;i<list.size();i++) {
Integer elt=list.get(i);
if (elt.compareTo(plusPetit)<0)
plusPetit=elt;
}
return plusPetit;
}
}
public static void main(String[] args) {
List<List<Integer>>list = new ArrayList<>();
list.add(Arrays.asList(5,9,11));
list.add(Arrays.asList(5,1,11));
list.add(Arrays.asList(5,9,2));
System.out.println(getMinimum(Arrays.asList(5,9,11))); // affiche 5
System.out.println(lePlusPetit(list)); // affiche 1

23/10/18