/*
* Tp (noté) no. 3
*/
package tp3;
/**
*
* @author Courtieu
* L'idée de cette classe est de fournir plusieurs implantations buggée des
* fonctions à tester et de voir si les tests des étudiants détectent les cas
* d'erreur pour chaque version buggée.
*/
public class Tp3 {
private static boolean charLe(char c,char d){
char a = Character.toLowerCase(c);
char b = Character.toLowerCase(d);
return a<=b;
}
private static boolean charLt(char c,char d){
char a = Character.toLowerCase(c);
char b = Character.toLowerCase(d);
return a<b;
}
private static boolean isStrictLetter(char c){
return charLe('a',c) && charLe(c,'z');
}
/** CETTE MÉTHODE N'EST PAS À IMPLANTER.
Retourne une copie de la chaîne {@code s} en ne gardant que les lettres
de l'alphabet comprises entre les lettres {@code c1} et {@code c2}
(bornes comprises). Les caractères qui ne sont pas des
lettres de l'alphabet (',', 'é', 'à', etc) sont également gardés. Les
caractères restent dans le même ordre que dans le mot d'origine.
<p>
ex: {@code sansRepetition ("xxt,ozt,xy", 'x','z')] retourne {@code "xx,z,xy"}
<p>
Dans le cas où s est null, lève une {@link NullPointerException}.
Dans le cas où {@code c1} (respectivement {@code c2}) n'est
pas une lettre, on considère que {@code c1 == 'a'}
(respectivement {@code c2 == 'z'}).
Dans le cas où {@code c2} est avant {@code c1} dans l'alphabet,
aucune lettre n'est gardée.
Les majuscules et minuscules sont considérée comme des lettres identiquess.
<p>
@param s la chaîne à analyser
@param c1 borne inférieure des lettres à garder (la borne est comprise)
@param c2 borne supérieure des lettres à garder (la borne est comprise)
@return Une copie de s contenant uniquement les lettres comprises entre
{@code c1} et {@code c2} et les caractères autres que des lettres.
@throws NullPointerException si s est null
*/
public static String sousAlphabet(String s, char c1, char c2) {
if(s==null) throw new NullPointerException();
char inf = c1;
char sup = c2;
if(!isStrictLetter(c1)) inf='a';
if(!isStrictLetter(c2)) sup='z';
StringBuffer res;
res = new StringBuffer(s);
int j=0;
for(int i = 0; i < s.length(); i = i +1){
char c = s.charAt(i);
if (charLe(inf,c) && charLt(c,sup) || ! isStrictLetter(c)) { // BUG: LT instead of LE
j=j+1;
} else {
System.out.println("DELETE char "+c+"\n");
if(isStrictLetter(c)) System.out.println("isStrictLetter");
res.deleteCharAt(j);
}
}
return new String(res);
}
/** Prend en argument un tableau, et renvoie la seconde plus grande valeur
dans ce tableau.
<p>
Formellement, si max(tab) est la plus grande valeur dans le tableau,
renvoie une valeur du tableau strictement inférieure à max(tab), mais
supérieure à toutes les autres.
<p>
Dans tous les cas où il n'y a pas de seconde valeur définie dans le
tableau, retourne RuntimeException.
<p>
Quelques exemples :
<ul>
<li> pour {8,2,5,7}, renverra 7
<li> pour {8,8, 2, 6, 7,7, 2,2,2} renverra 7
</ul>
@param tab
@return la seconde plus grande valeur du tableau.
@throws RuntimeException en cas de problème de définition.
*/ /* PAS DE BUG */
public static int secondeValeur(int tab[]) {
if (tab == null) {
throw new RuntimeException();
}
if (tab.length == 0) {
throw new RuntimeException();
}
int max = tab[0];
int sec = tab[0];
for (int n : tab) {
if (n > max) {
sec = max;
max = n;
} else if (n < max && (sec == max || n > sec) ) {
sec = n;
}
}
if (sec == max) {
throw new RuntimeException();
} else {
return sec;
}
}
}