web-dev-qa-db-fra.com

Comment vérifier si un personnage est une voyelle?

Ce code Java me pose problème:

    String Word = <Uses an input>
    int y = 3;
    char z;
    do {
        z = Word.charAt(y);
         if (z!='a' || z!='e' || z!='i' || z!='o' || z!='u')) {
            for (int i = 0; i==y; i++) {
                wordT  = wordT + Word.charAt(i);
                } break;
         }
    } while(true);

Je veux vérifier si la troisième lettre de Word est une non-voyelle et si c'est ce que je veux, elle renverra la non-voyelle et tous les caractères qui la précèdent. S'il s'agit d'une voyelle, il vérifie la lettre suivante de la chaîne. S'il s'agit également d'une voyelle, il vérifie la lettre suivante jusqu'à trouver une non-voyelle.

Exemple:

Word = Jaemeas alors wordT doit = ​​Jaem

Exemple 2:

Word = Jaeoimus alors wordT doit = ​​Jaeoim

Le problème vient de ma déclaration if. Je ne vois pas comment lui faire vérifier toutes les voyelles de cette ligne.

javastringcharindexoftruncation
11
KyleMHB

Votre condition est imparfaite. Pensez à la version la plus simple

z != 'a' || z != 'e'

Si z est 'a', alors la seconde moitié sera vraie puisque z ne sera pas 'e' (c’est-à-dire que la condition entière est vraie) et si z est 'e' alors la première moitié sera vraie puisque z ne sera pas 'a' (encore, la condition entière sera vraie). Bien sûr, si z n'est ni 'a' ni 'e', alors les deux parties seront vraies. En d'autres termes, votre condition ne sera jamais fausse!

Vous voudrez probablement que &&s soit présent à la place:

z != 'a' && z != 'e' && ...

Ou peut-être:

"aeiou".indexOf(z) < 0
26
arshajii

Méthode propre pour vérifier les voyelles:

public static boolean isVowel(char c) {
  return "AEIOUaeiou".indexOf(c) != -1;
}
44
Silviu Burcea

Que diriez-vous d'une approche utilisant des expressions régulières? Si vous utilisez le modèle approprié, vous pouvez obtenir les résultats de l'objet Matcher à l'aide de groupes. Dans l'exemple de code ci-dessous, l'appel à m.group (1) devrait vous renvoyer la chaîne que vous recherchez tant qu'il existe une correspondance de motif.

String wordT = null;
Pattern patternOne = Pattern.compile("^([\\w]{2}[AEIOUaeiou]*[^AEIOUaeiou]{1}).*");
Matcher m = patternOne.matcher("Jaemeas");
if (m.matches()) {
    wordT = m.group(1);
}

Juste une approche légèrement différente qui atteint le même objectif.

3
jmtrachy

Pour commencer, vous vérifiez si la lettre est "pas un" OR "pas e" OR "pas i" etc.

Disons que la lettre est i. Alors la lettre n'est pas un, de sorte que retourne "True". Alors la déclaration entière est vraie parce que i! = A. Je pense que ce que vous recherchez, c’est d’étudier ET les déclarations ensemble, pas OR.

Une fois que vous avez fait cela, vous devez regarder comment incrémenter y et vérifier à nouveau. Si la première fois que vous obtenez une voyelle, vous voulez voir si le caractère suivant est également une voyelle ou non. Cela ne fait que vérifier le caractère à l'emplacement y = 3.

1
Drifter64

En réalité, il existe des moyens beaucoup plus efficaces de le vérifier, mais puisque vous avez demandé quel est le problème avec le vôtre, je peux dire que le problème est que vous devez changer les opérateurs OR avec les opérateurs AND. Avec votre déclaration if, ce sera toujours vrai.

1
Mehmet Sedat Güngör

J'ai déclaré une constante char [] pour les voyelles, puis mis en œuvre une méthode qui vérifie si un caractère est une voyelle ou non (retourne une valeur booléenne). Dans ma méthode principale, je déclare une chaîne et la convertis en un tableau de caractères afin de pouvoir passer l'index du tableau de caractères comme paramètre de ma méthode isVowel: 

public class FindVowelsInString {

        static final char[] VOWELS = {'a', 'e', 'i', 'o', 'u'};

        public static void main(String[] args) {

            String str = "hello";
            char[] array = str.toCharArray();

            //Check with a consonant
            boolean vowelChecker = FindVowelsInString.isVowel(array[0]);
            System.out.println("Is this a character a vowel?" + vowelChecker);

            //Check with a vowel
            boolean vowelChecker2 = FindVowelsInString.isVowel(array[1]);
            System.out.println("Is this a character a vowel?" + vowelChecker2);

        }

        private static boolean isVowel(char vowel) {
            boolean isVowel = false;
            for (int i = 0; i < FindVowelsInString.getVowel().length; i++) {
                if (FindVowelsInString.getVowel()[i] == vowel) {
                    isVowel = true;
                }
            }
            return isVowel;
        }

        public static char[] getVowel() {
            return FindVowelsInString.VOWELS;
        }
    }
0
paranza
 String Word="Jaemeas";
 String wordT="";
        int y=3;
        char z;
        do{
            z=Word.charAt(y);
             if(z!='a'&&z!='e'&&z!='i'&&z!='o'&&z!='u'&&y<Word.length()){
                for(int i = 0; i<=y;i++){
                    wordT=wordT+Word.charAt(i);
                    }
            break;
            }
           else{
                 y++;
             }

        }while(true);

voici ma réponse. 

0
user2838970

Donc, au cas où quelqu'un rencontrerait cela et voudrait une méthode de comparaison facile qui puisse être utilisée dans de nombreux scénarios. 

Peu importe qu'il s'agisse de MAJUSCULES ou de minuscules. A-Z et a-z.

voyelle booléenne = ((1 << lettre) & 2130466)! = 0;

C'est le moyen le plus simple auquel je puisse penser. J'ai testé cela en C++ et sur un PC 64 bits, les résultats peuvent donc différer, mais en principe, seuls les 32 bits disponibles dans un "entier 32 bits" sont supprimés. la "<< lettre". 

Si vous ne comprenez pas comment fonctionnent les bits, désolé, je ne vais pas aller en profondeur mais la technique de 

1 << N est la même chose que 2 ^ N puissance ou création d'une puissance de deux.

Ainsi, lorsque nous effectuons 1 << N & X, nous vérifions si X contient la puissance de deux qui crée notre voyelle se trouve dans cette valeur 2130466. Si le résultat n'est pas égal à 0, il s'agissait d'une voyelle. 

Cette situation peut s'appliquer à tout ce pour quoi vous utilisez des bits et même des valeurs supérieures à 32 pour un index fonctionneront dans ce cas, à condition que la plage de valeurs soit comprise entre 0 et 31. Ainsi, les lettres mentionnées précédemment pourraient être 65-90 ou 97. -122 mais depuis mais nous continuons à supprimer 32 jusqu'à ce qu'il nous reste un reste allant de 1-26. Le reste n'est pas la façon dont cela fonctionne réellement, mais cela vous donne une idée du processus. 

Si vous n’avez aucune garantie sur les lettres entrantes, gardez bien à l’esprit de vérifier si la lettre est inférieure à «A» ou supérieure à «u». Comme les résultats seront toujours faux de toute façon. 

Par exemple, ce qui suit retournera une fausse voyelle positive. "!" le point d'exclamation est la valeur 33 et il fournira la même valeur binaire que «A» ou «a».

0
Jeremy Trifilo