1  Les objectifs

2  Classe Palindrome

2.1  estPalindrome1 : String charAt(i)

• L'accès à chaque caractère se fera à l'aide de la fonction charAt de la classe String.
• L'algorithme commence par positionner un indice d au début et un indice f à la fin de la chaîne, puis entre dans une boucle comprenant toutes les étapes suivantes :
  - incrémenter d tant que le caractère correspondant est non-alphabétique
  - décrémenter f tant que le caractère correspondant est non-alphabétique
  - comparer les deux caractères (en d et f) après les avoir convertis en minuscule
  - ce n'est pas un palindrome s'ils sont différents
  - incrémenter d et décrémenter f
  - décider si la boucle doit continuer ou non
• Pour un premier test automatique :
  insérer dans le projet la classe Palindrome1Test , faire Tout tester, puis cliquer sur chaque ligne non "verte" pour connaître la raison de l'échec.

2.2  estPalindrome2 : tableau[i]

• La méthode commencera par convertir la chaîne en un tableau de caractères à l'aide d'une fonction de la classe String.
• L'accès à chaque caractère se fera alors par simple indiçage de ce tableau.
• L'algorithme à utiliser est le même que celui de la version 1.

2.3  estPalindrome3 : ArrayList get(i)

• La méthode commencera par construire une ArrayList de Character en parcourant tous les caractères de la chaîne et en ajoutant à la collection que les caractères alphabétiques après les avoir convertis en minuscule.
• L'accès à chaque caractère se fera alors par la fonction get de la classe ArrayList.
• L'algorithme à utiliser est plus simple que celui de la version 1 puisque la collection est débarassée des caractères non-alphabétiques. Il suffit donc de calculer le milieu de la chaîne et de comparer les caractères symétriquement par rapport à ce milieu.

2.4  estPalindrome4 : reverse equals

• La méthode commencera par construire une ArrayList de Character de la même façon que la version 3.
• Ensuite, nul besoin d'accéder à chaque caractère !
• L'algorithme à utiliser consiste à inverser * l'ordre des éléments d'une copie de la collection, puis à comparer les deux collections; c'est tout (* voir la classe Collections).

2.5  Les tests

• A la main :
  écrire une procédure essai qui saisira une phrase (à l'aide d'une fonction de la classe JOptionPane et qui appellera les méthodes palindromeX et affichera leur résultat.
  Quelques exemples : "radar", "elle", "Esope reste ici et se repose."
• Automatiquement :
  insérer dans le projet la classe PalindromeTest , faire Tout tester, puis cliquer sur chaque ligne non "verte" pour connaître la raison de l'échec.

3  Classe Matrice

1. Écrire une fonction a3Chiffres qui prend un paramètre réel et qui le retourne tronqué au-delà de 3 chiffres après la virgule.
2. Écrire une fonction initMat qui prend un paramètre entier N et qui retourne un tableau bi-dimensionnel de N lignes et de 5 colonnes contenant les valeurs spécifiées précédemment,
   en passant par la fonction a3Chiffres pour les racines.
3. Écrire une procédure afficheMat qui prend en param
   etre une matrice telle que décrite ci-dessus et qui l'affiche en espaçant les valeurs par des tabulations (\t).
4. Essai à la main :
   écrire une procédure essai qui appellera initMat avec la le paramètre 20 puis qui appellera afficheMat.
5. Automatiquement :
   insérer dans le projet la classe MatriceTest , faire Tout tester, puis cliquer sur chaque ligne non "verte" pour connaître la raison de l'échec.

4  Classe Moyenne

1. Écrire une fonction moyenne3 prenant un paramètre de type ArrayList de Double et retournant un double.
2. Pour la tester à la main :
   écrire une procédure essaiMoyenne3 qui demande un nombre à l'utilisateur et l'ajoute à la collection tant que ce nombre est positif ou nul. Il suffit ensuite d'afficher le résultat de la fonction moyenne3.
3. Pour la tester automatiquement :
   insérer dans le projet la classe MoyenneTest , faire Tout tester, puis cliquer sur chaque ligne non "verte" pour connaître la raison de l'échec.

5  Classe Eratosthene

debut :  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
raye 2:  2  3  /  5  /  7  /  9  / 11  / 13  / 15  / 17  / 19  / 21  / 23  / 25
raye 3:  2  3     5     7     /    11    13     /    17    19     /    23    25
raye 5:  2  3     5     7          11    13          17    19          23     /
raye 7:  ...
 

1. Écrire une procédure initV qui initialise à VRAI les N-1 derniers éléments du tableau passé en paramètre, pour signifier qu'a priori, tous les nombres entiers (sauf 0 et 1) sont candidats à être premiers (N est également passé en paramètre).
2. Écrire une procédure raye qui applique la méthode décrite ci-dessus en mettant FAUX dans le tableau passé en paramètre pour chaque case correspondant à un nombre qu'elle doit "rayer" (inférieur ou égal au nombre N également passé en paramètre).
   Remarque : il est inutile de parcourir TOUS les nombres jusqu'à N.
   Question : quand peut-on arrêter la boucle principale ?
3. Écrire une fonction prepare qui prend en paramètre le nombre N (correspondant à la LIMITE évoquée ci-dessus) et qui retourne un tableau de booléens.
   Cette fonction commencera par créer le tableau de booléens avec la bonne taille en fonction de N, puis appellera les procédures initV et raye.
4. Écrire une fonction booléenne estPremier qui prend en paramètre l'entier à tester et qui utilise évidemment la fonction prepare pour déterminer ensuite si l'entier est premier ou non.
5. Écrire une procédure affiche qui affiche l'intégralité des nombres premiers figurant dans le tableau passé en paramètre (jusqu'à la limite N également passée en paramètre), à raison de 10 par ligne (utiliser des tabulations).
6. Pour tester à la main :
   écrire une procédure run qui déclare un tableau de booléens, demande quelle action on veut faire (voir ci-dessous), puis effectue l'action, ceci tant qu'on ne désire pas arrêter le programme.
   Pour choisir l'action, on saisira un nombre de 0 à 3 :
   • 0 pour sortir de la boucle et arrêter le programme
   • 1 pour appeler la procédure affiche (saisir la limite)
   • 2 pour tester si un nombre est premier ou non (saisir ce nombre)
   • 3 pour trouver le plus grand nombre premier inférieur ou égal à un nombre (saisir ce nombre)
   On supposera que l'utilisateur n'entre que des nombres entiers.
7. Pour tester automatiquement :
   insérer dans le projet la classe EratostheneTest , faire Tout tester, puis cliquer sur chaque ligne non "verte" pour connaître la raison de l'échec.

      2      3      5      7     11     13     17     19     23     29
     31     37     41     43     47     53     59     61     67     71
     73     79     83     89     97    101    103    107    109    113
    127    131    137    139    149    151    157    163    167    173
    179    181    191    193    197    199    211    223    227    229
...
 

6  Classe Anagrammes

1. Écrire la procédure init0 qui initialise à 0 chaque case du tableau de comptage passé en paramètre (le rôle d'un tableau de comptage est de stocker pour chaque lettre de l'alphabet le nombre de fois qu'elle apparaît dans la phrase).
2. Écrire la procédure compte qui prend une chaîne de caractères en 1^er paramètre et remplit le tableau de comptage passé en 2^ème paramètre.
   Contrainte : tout switch est interdit.
   Rappel : des méthodes utiles vous ont été indiquées à l'exercice sur les palindrômes du TD6.
   Aide : "x,  x-x=0
3. Écrire la fonction booléenne verif qui créera les deux tableaux de comptage (un pour chaque phrase) et qui appellera pour chacun d'eux :
   • la procédure init0 pour initialiser ce tableau,
   • la procédure compte pour compter dans ce tableau les occurences ² de chaque lettre de l'alphabet dans la chaîne ;
   Enfin, elle comparera les deux tableaux de comptage.
4. Pour tester à la main :
   appeler la méthode verif sur les exemples suivants :
   tartines et satiner ne sont pas des anagrammes.
   "Mer : Danger !" et "grand-mere" sont des anagrammes.
5. Pour tester automatiquement :
   insérer dans le projet la classe AnagrammesTest , faire Tout tester, puis cliquer sur chaque ligne non "verte" pour connaître la raison de l'échec. .

Notes: