Discussion :

[salimoush]

Bonjour,

J'essaie en vain d'écrire une méthode qui retournerait ces valeurs :
— true : si la chaîne contient uniquement des caractères dans l’intervalle [cMin, cMax]
— false : si la chaîne inclus au moins un caractère qui n’est pas dans l’intervalle [cMin, cMax]

En fait, je veux vérifier que ma chaîne de caractère ne contient que des lettres de l'alphabet en utilisant seulement les méthodes suivantes: charAt() et length().

Auriez-vous une solution?

Merci!!!

[joel.drigo]

Salut,

Si cMIn et cMax sont des caractères (char), il suffit de comparer : si cMin<=c && c<=cMax alors c appartient à l'intervalle. Et c = string.charAt(i) avec i variant de 0 à string.length-1, tout simplement.

[salimoush]

Merci!

Que veut dire ton c dans cMin<=c && c<=cMax?
Merci.

[salimoush]

Oops, je suis vraiment à l'ouest, tu as expliqué comment on obtient c juste après lol.
Ne tiens pas compte de ma précédente demande...

[salimoush]

J'ai mal compris ce que tu m'as expliqué. Ca m'affiche n résultats en fonction de n caractères que j'entre...
Je colle ici mon code pour avoir de l'aide svp:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void main (String[] args) {
        String chaine;
        char cMin;
        char cMax;
        int longueur;        
        cMin='a';
        cMax='z';
 
        System.out.println("Chaine?");
        chaine=Clavier.lireString();
        for ( int i = 0; i < chaine.length(); i++ ) {
            if ( chaine.charAt( i ) >=cMin && chaine.charAt( i )<=cMax  ) {
                System.out.println("true");
            }else{
                System.out.println("false");
            }
        }
    } // main

[joel.drigo]

Tout est dans la description :

une méthode qui retournerait ces valeurs :
— true : si la chaîne contient uniquement des caractères dans l’intervalle [cMin, cMax]
— false : si la chaîne inclus au moins un caractère qui n’est pas dans l’intervalle [cMin, cMax]

La fonction est globable : on a soit true soit false, alors qu'afficher true ou false pour chaque caractère, affiche forcément plusieurs fois true ou false. La fonction vaut donc : caractère 0 est dans [cMin, cMax] et caractère 1 est dans [cMin, cMax] et caractère 3 est dans [cMin, cMax] et ... Bien sûr, on ne peut pas faire autant de if qu'il y a de caractères : on va faire ça dans une boucle, et faire que chaque test fait dans chaque itération se cumule pour n'avoir qu'une seule valeur true ou false.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
boolean resultat=true;
for (int i = 0; i < s.length(); i++) {
	char c = s.charAt(i);
	resultat &= (c >= cMin && c <= cMax); // cumule avec &=
}
System.out.println( resultat );

Ensuite, on peut simplifier. On sait que pour un et, il suffit qu'un seul test soit faux pour que la combinaison et de tous les tests est forcément false (en algère booléenne : a & false est false, donc a & b & false est false, a & b & c & false est false, etc.

Donc il suffit de faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
	public static boolean containsOnly(String s, char cMin, char cMax) {
		if ( s.length()==0 ) {
		    // la chaine est vide (ou null), alors il n'y a aucun caractère dans l'intervalle, 
			// mais on ne peut pas dire non plus qu'il y a au moins caractère qui n'est pas dans l'intervalle
			// il ne faudrait pas appeler cette méthode avec une chaine vide (ou null, mais dans ce cas ça va faire une NullPointerException)
			// on peut retourner n'importe quoi comme valeur, aucune des deux n'a de sens
			// on va soulever une exception pour dire qu'on ne devrait pas appeler cette méthode dans ce cas
			throw new IllegalArgumentException("String is empty");
		}
		else if ( cMin>cMax ) {
			// l'intervalle est incorrect, on soulève une exception
			throw new IllegalArgumentException("cMin > cMax");
		}
		else {
			for (int i = 0; i < s.length(); i++) {
				char c = s.charAt(i);
				if (c < cMin || c > cMax) { // le caractère n'est pas dans l'intervalle
					return false; // alors on a au moins un caractère qui n'est pas dans l'intervalle, donc le résultat est false
			        }
			}
			return true; // tous les caractères étaient forcément dans l'intervalle alors le résultat est true
		}
	}