Les alternatives du Bug

../../_images/cond.png

L’objectif de ce TP est :

  • Déterminer des structures conditionnelles (alternatives et conditions) et les implémenter.

  • Produire le comportement attendu du/des Bug(s).

Les structures conditionnelles en Java

La structure if

Elle permet d’effectuer des traitements conditionnels. Sa syntaxe est la suivante :

if ( expression booléenne ) {
    // bloc d'instructions A
} else {
    // bloc d'instructions B
}

Lors de l’exécution du programme, si l’évaluation de l’expression booléenne donne vrai, alors le bloc d’instructions A est exécuté, sinon le bloc d’instructions B est exécuté.

Si le bloc d’expression B est vide, le mot clef else et le bloc qui suit peuvent être omis :

if ( expression booléenne ) {
    // bloc d'instructions
}

Lors de l’exécution du programme, le bloc d’instructions ne sera exécuté que si l’évaluation de l’expression booléenne donne vrai.

Enfin, si le bloc d’expression se résume à une seule expression, les accolades peuvent être enlevées. Par exemple:

int x, y;
//...
if (x > y)
    System.out.println("x est plus grand");
else
    System.out.println("y est plus grand");

La structure switch

La structure de contrôle switch permet d’effectuer des traitements suivant des valeurs possibles d’une expression entière. Sa syntaxe est la suivante :

switch (expression) {
case constante1:
    // ...
    break;
case constante2:
    // ...
    break;
// ...
default:
    // ...
    break;
}

L’expression est évaluée, puis l’exécution du programme continue à partir de l’étiquette case dont la constante est égale à la valeur de l’expression. L’exécution continue alors jusqu’à la première instruction break rencontrée. Si aucune étiquette ne correspond, l’exécution continue à partir de l’étiquette spéciale default si elle existe. L’étiquette default peut en effet être omise.

Attention, si une instruction break n’est pas mise, l’exécution peut continuer au cas suivant.

Par exemple, le fragment de code suivant affichera A si x vaut 0, BC si x vaut 1, C si x vaut 2, et D dans tous les autres cas.

int x;
// ...
switch (x) {
case 0:
    System.out.print("A");
    break;
case 1:
    System.out.print("B");
case 2:
    System.out.print("C");
    break;
default:
    System.out.print("D");
    break;
}

Défi n°1 : alcôves

État initial

  • Sept Bugs alignés sur une grille de 7x7 cases.

  • Des murs limitant les mouvements des Bugs.

Résultat attendu

  • Tous les Bugs sont positionnés dans les alcôves.
../../_images/init11.png ../../_images/result11.png

À faire

  1. Récupérer l'archive du programme, l’enregistrer dans le dossier du TP puis la décompresser.

    Le programme comprend les mêmes classes et fichiers que pour le TP précédent. Se reporter à l’énoncé du TP Le monde des Bugs pour les détails et pour la référence de l’API.

  2. Compiler le programme tel qu’il est fourni, pour vérifier qu’il n’y a pas d’erreur et que l’état initial est bien celui reproduit ci-dessus.

Contrairement au TP précédent, le monde comprend ici plusieurs Bugs. Leur comportement demeure individuellement le même ; chaque Bug exécutera à son tour le programme de la méthode enRoute(). La difficulté est donc de concevoir un programme unique qui s’applique à chaque Bug tout en permettant de parvenir au résultat.

À faire

  1. Déterminer l’algorithme permettant aux Bugs de se positionner convenablement, puis l’implémenter. Il faut être doux avec les Bugs et ne pas les faire se cogner aux murs.

  2. Régler la vitesse en utilisant la méthode setVitesse() dont le paramètre est un nombre de mouvements par seconde.

Correction

Bug.java

Défi n°2 : intervalles

Préparatifs

Pour les défis suivants, nous n’aurons besoin que d’un seul Bug et nous allons utiliser le fichier dirigé vers l’entrée standard pour fournir des valeurs au Bug, qui les interprètera puis nous fournira des réponses sous forme de messages.

À faire

  1. Modifier la valeur de la constante N_BUGS dans le fichier Main.java, pour la positionner à 1.

  2. Positionner la variable readMaze à false (dans le fichier Main.java).

  3. Supprimer le fichier Bug.java.

  4. Récupérer le squelette du nouveau fichier Bug.java permettant au Bug d’utiliser un fichier pour lire les valeurs de test depuis l’entrée standard. L”enregister à la place de l’ancien (et le renommer Bug.java, naturellement).

Les ados

Un ado se caractérise par son âge, compris entre 13 et 19 ans (inclus). On va soumettre des groupes de trois valeurs entières (a, b, et c) au Bug et si au moins l’une de trois correspond à l’âge d’un ado, alors le Bug nous dira : ado ; Dans le cas contraire, il nous dira : pas ado.

À faire

  1. Compléter le fichier Bug.java pour intégrer le calcul demandé. La lecture des valeurs a, b, et c est déjà réalisée, pour l’exemple.

  2. Récupérer le fichier data1.test comprenant un jeu de valeurs de test.

  3. Soumettre les valeurs de test à votre programme. Les réponses du Bug doivent être les suivantes :

Ado
Ado
Pas ado
Ado
Ado
Pas ado

Correction

Bug.java

Défi n°3 : intervalles 2D

On considère un Bug sur une grille 12x12 dans laquelle on distingue deux zones :

  • la zone rouge contenant la ligne 0

  • la zone bleue contenant la ligne 11

La démarquation entre ces deux zones est materialisée par des murs.

On fournit alors au Bug des coordonnées de cases et il doit :

  1. se rendre sur la case désignée

  2. peindre la case de la couleur du nom de la zone associée.

État initial

  • Un Bug sur une grille de 12x12, attendant de recevoir des coordonnées.

  • Des murs délimitant les zones rouge et bleue.

Résultat attendu

  • Toutes les cases visitées par le Bug sont marquées de la bonne couleur.
../../_images/init22.png ../../_images/result22.png

À faire

  1. Positionner la variable readMaze à true et les dimensions de la grille à 12x12 dans la classe Main.

  2. Récupérer le fichier data2.test. Ce fichier contient cette fois trois parties :

  • au début : les positions des murs ;

  • la ligne 0 0 endWalls qui marque la fin des définitions de murs ;

  • le jeu de valeurs de test qui seront lues par le Bug.

  1. Récupérer le squelette du fichier Bug.java.

  2. Concevoir le test à réaliser pour identifier la zone associée à la case désignée par chaque ligne du jeu de données test.

  3. Implémenter ce test pour parvenir au résultat attendu. On peut également s’aider des messages en console pour mettre au point le programme, avec une sortie de ce type

x=1, y=4 --> bleu
x=7, y=2 --> rouge
x=10, y=2 --> rouge
x=10, y=6 --> bleu
x=2, y=0 --> rouge
x=6, y=10 --> bleu
x=9, y=4 --> rouge
x=2, y=4 --> bleu
x=1, y=11 --> bleu
x=5, y=10 --> bleu

Correction

Bug.java

Défi n°4 : le Bug des maths

On va soumettre au Bug des opération arithmétiques simples du type op1 opérateur op2, où l’opérateur représentera l’une des opérations élémentaires suivantes :

  • addition +

  • soustraction -

  • multiplication x

  • division /

Le Bug devra lire les opérations décrites dans le fichier de données test et fournir chaque fois le résultat sous forme de message dans la console.

Note

Les messages émis par les Bugs sont en fait générés par de simples appels à la méthode System.out.println(String).

À faire

  1. Positionner la variable readMaze à false.

  2. Récupérer le fichier data3.txt contenant le jeu de données test.

  3. Recupérer le fichier Bug.java comme squelette de travail du fichier Bug.java.

  4. Concevoir l’algorithme qui interpréte les lignes du fichier et fournit le résultat. Écrire deux variantes : l’une avec des if et l’autre avec un switch.

  5. Implémenter les deux versions de l’algorithme, sans oublier de les commenter.

  6. Vérifier la validité des résultats et commenter celui de la dernière opération.

  7. Réflechir à la question : quelle est la meilleure des versions ?

Avertissement

Les valeurs lues dans le fichier ne sont plus des entiers. Consulter la documentation de la classe Double.

Correction

Bug.java

Défi n°5 : le Bug de l’an 2000

Le Bug va vous aider à déterminer si une année donnée est bissextile ou non. À toute fin utile, on en rappelle la définition : Une année est bissextile si et seulement si elle est divisible par 4, mais pas par 100. Les années divisibles par 400 sont toutefois bissextiles.

À faire

  1. Récupérer le fichier data4.txt contenant le jeu de données test.

  2. Concevoir l’algorithme qui interpréte les lignes du fichier et fournit le résultat, comme ci-dessous

    1900 n'est pas bissextile
1984 est bissextile
2000 est bissextile
2010 n'est pas bissextile
2100 n'est pas bissextile
fini !

  3. Adapter le code du fichier Bug.java pour rendre la partie lecture compatible avec les données à lire.

  4. Implémenter l’algorithme et vérifier son bon fonctionnement à l’aide des exemples de résultats fournis ci-dessus.

Correction

Bug.java

Défi n°6 : le petit Bug illustré

Le Bug est très à cheval sur l’orthographe. Parmi les erreurs qu’il ne peut s’empêcher de corriger, l’oubli de la majuscule en début de phrase figure en bonne place.

Au travers d’un fichier et à raison d’une par ligne, vous allez donc soumettre au Bug un certain nombre de phrases qu’il lira une à une et dont il déterminera si elles commencent bien par une majuscule. Si ce n’est pas le cas, il effectuera la correction et comptabilisera les erreurs. À la fin du traitement, il donnera une note en pourcentage de phrases dont la majuscule était convenablement placée.

Indication

  • Plusieurs approches sont envisageables pour déterminer si une lettre est une majuscule, en particulier :

    • utiliser les intervalles de la table ASCII.

    • comparer la lettre et sa version après mise en majuscule.

    La seconde vous est conseillée ; Elle vous donnera également l’occasion d’utiliser la documentation de référence Java (classe String).

  • Pour lire une ligne entière sur l’entrée standard, il faut utiliser la méthode nextLine() de la classe Scanner à la place de la méthode next() qui se contente de lire le prochain élément en s’arrètant dès le premier délimiteur rencontré (par défaut le caractère d’espacement).

À faire

  1. Récupérer le fichier data5.txt contenant le jeu de phrases test.

  2. Concevoir l’algorithme qui interpréte les lignes du fichier et fournit le résultat, comme ci-dessous, puis l’implémenter.

    Lorem ipsum dolor sit amet
Consectetur adipisicing elit, sed do eiusmod
Tempor incididunt ut labore et
Dolore magna aliqua. Ut enim ad minim veniam,
Quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
Consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse
Cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
Proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
-------- fin de la correction ----------
Note : 50.0% de bonnes phrases.

  3. Adapter le code du fichier Bug.java pour rendre la partie lecture compatible avec les données à lire.

  4. Implémenter l’algorithme et vérifier son bon fonctionnement à l’aide de l’exemples de résultat ci-dessus.

Correction

Bug.java