连续两次检查相同的元音

Question

我正在尝试编写一个程序（实际上是程序的一部分）来检查是否有任何元音连续出现两次。对于前。 input = boo, output = o

这是我目前的代码：

//j - displays any vowels which occur consecutively
System.out.print("\nj. ");

// have to give these variables a value
// otherwise the default statements won't work
char current_letter_1 = ' ', current_letter_2 = ' ';

//making strings for these characters so they are easier to output
String current_letter_1_string = String.valueOf(current_letter_1);
String current_letter_2_string = String.valueOf(current_letter_2);

//checking it against the sentence in lowercase so it's case insensitive
char low_letter = e.charAt(ind);

while (ind < a) {
    current_letter_1_string = String.valueOf(current_letter_1);
    current_letter_2_string = String.valueOf(current_letter_2);

    low_letter = e.charAt(ind);

    switch (low_letter) {
        case 'a', 'e', 'i', 'o', 'u', 'y':
            current_letter_1 = low_letter;
            break;
        default:
            break;
    }
    ind += 1;
    switch (low_letter) {
        case 'a', 'e', 'i', 'o', 'u', 'y':
            current_letter_2 = low_letter;
            break;
        default:
            break;
    }
    if (current_letter_1 == current_letter_2) {
        System.out.print(current_letter_2_string.trim() + " ");
    } else {
    }
    //in case the same vowel is repeated more than twice in a row
}
while (low_letter == current_letter_2 && ind < a) {
    low_letter = e.charAt(ind);
    ind += 1;
}
if (low_letter != current_letter_2) {
    ind += 1;
} else {
}

顺便说一句，因为这是一个更大程序的一个小节，我会给你一些变量值：

Scanner sc(System.in);
String sentence = sc.nextLine();
int a = sentence.length();
String e = sentence.toLowerCase();
int ind = 0;

另外，这是给学校的，所以如果它看起来真的很奇怪，而你会以完全不同的方式来做，请多多包涵。这段代码有点可以用，但是输出总是很奇怪，即使是trim()，输出的变量还是前面加了space。此外，如果 sentence 包含多个重复的元音，输出将再次搞砸。非常感谢任何帮助。

Answer 1

保持简单。

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter a text: ");
        String sentence = sc.nextLine();

        // Text in the lower case
        String sentenceLowerCase = sentence.toLowerCase();

        // Check all but the last char if it is same as its following character and if
        // it's a vowel
        for (int i = 0; i < sentence.length() - 1; i++) {
            char ch = sentenceLowerCase.charAt(i);
            if (ch == sentenceLowerCase.charAt(i + 1)
                    && (ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u')) {
                System.out.println(ch);
            }
        }
    }
}

样本运行:

Enter a text: Booster and rooster are different things
o
o

另一个样本运行:

Enter a text: Faaster is a wrong spelling. Boost your vocabulary.
a
o

Answer 2

完整代码如下：

import java.util.Scanner;
//also using java.lang.StringBuilder and java.lang.Character

public class Ch6Extra1 {

    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);
        
        String sentence;
        
        
        do {
            System.out.print("Enter a sentence: ");
            sentence = sc.nextLine();
            
        } while (sentence.equals(null) || sentence.equals(""));
            
        
        //variables used throughout code
        int ind = 0;
        char letter = sentence.charAt(ind);
        
        //a - character counter
        int a;
        a = sentence.length();
        
        System.out.print("\na. " + a);
        
        //b - word counter
        int b;
        b = 0;
        
        while (ind < a) {
            
            letter = sentence.charAt(ind);
            
            switch (letter) {
                
                case ' ':
                    b += 1;
                    break;
                    
                default:
                    break;
            }
            ind += 1;
        }
        b += 1;
        ind = 0;
        
        System.out.print("\nb. " + b);
        
        //c - sentence reversed
        StringBuilder c = new StringBuilder(sentence);
        StringBuilder rev_sentence = c.reverse();
        
        System.out.print("\nc. " + rev_sentence);
        
        //d - sentence to uppercase
        String d;
        d = sentence.toUpperCase();
        
        System.out.print("\nd. " + d);
        
        //e - sentence to lowercase
        String e;
        e = sentence.toLowerCase();
        
        System.out.print("\ne. " + e);
        
        //f, g and m - vowel, consonant, and punctuation count
        int f, g, m;
        f = 0;
        g = 0;
        m = 0;
        ind = 0;
        
        while (ind < a) {
            
            letter = sentence.charAt(ind);
            
            switch (letter) {
                case 'a', 'e', 'i', 'o', 'u', 'y', 'A', 'E', 'I', 'O', 'U', 'Y':
                    f += 1;
                    break;
                    
                //in case it's a number, the code will pass to the next char
                case 1, 2, 3, 4, 5, 6, 7, 8, 9:
                    break;
                 
                //in case it's a special character, the code will pass to the next char
                case 'b', 'B', 'c', 'C', 'd', 'D', 'f', 'F', 'g', 'G', 'h', 'H', 
                     'j', 'J', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N', 'p', 'P', 
                     'q', 'Q', 'r', 'R', 's', 'S', 't', 'T', 'v', 'V', 'w', 'W', 
                     'x', 'X', 'z', 'Z':
                    g += 1;
                    break;
                    
                //checks for punctuation
                case '.', ',', ';', ':', '?', '!':
                    m += 1;
                    break;
                    
                default:
                    break;
                    
            }
            ind += 1;
        }
        
        System.out.print("\nf. " + f);
        System.out.print("\ng. " + g);
        ind = 0;
        
        
        //h - ASCII of first word
        
        System.out.print("\nh. ");
        while (ind < a) {
            
            letter = sentence.charAt(ind);
            
            switch (letter) {
                
                case ' ':
                    ind = a -1;
                    break;
                    
                default:
                    System.out.print((int)letter + " ");
                    break;
            }
            ind += 1;
        }
        ind = 0;
        
        //i - checks for word and in the sentence
        boolean i = e.contains("and");
        
        if (i == true) {
            System.out.print("\ni. Yes");
        } else if (i == false) {
            System.out.print("\ni. No");
        }
        
        
        //j - displays any vowels which occur consecutively
        
        System.out.print("\nj. ");
        
        //have to give these variables a value otherwise the default statements won't work
        char current_letter_1 = ' ', current_letter_2 = ' ';
        
        //making strings for these characters so they are easier to output
        String current_letter_1_string  = String.valueOf(current_letter_1);
        String current_letter_2_string  = String.valueOf(current_letter_2);
        
        //checking it against the sentence in lowercase so it's case insensitive
        char low_letter = e.charAt(ind);
        
        while (ind < a) {
            
            current_letter_1_string  = String.valueOf(current_letter_1);
            current_letter_2_string  = String.valueOf(current_letter_2);
            
            low_letter = e.charAt(ind);
            
        
            switch (low_letter) {
                case 'a', 'e', 'i', 'o', 'u', 'y':
                    current_letter_1 = low_letter;
                    break;
                    
                default:
                    break;
                    
            }
            ind += 1;
            
            switch (low_letter) {
                case 'a', 'e', 'i', 'o', 'u', 'y':
                    current_letter_2 = low_letter;
                    break;
                    
                default:
                    break;
                    
                    
            } if (current_letter_1 == current_letter_2) {
                System.out.print(current_letter_2_string.trim() + " ");
                
            } else {
            }
                
            //in case the same vowel is repeated more than twice in a row
            } while (low_letter == current_letter_2 && ind < a){
                low_letter = e.charAt(ind);
                ind += 1;
                
            } if (low_letter != current_letter_2) {
                ind += 1;
            } else {
            }
        
        
        //k and l together - Upper and Lower case counters
        int k, l;
        k = 0;
        l = 0;
        
        boolean up_case = Character.isUpperCase(letter);
        boolean low_case = Character.isUpperCase(letter);
        
        while (ind < a) {
            
            up_case = Character.isUpperCase(letter);
            low_case = Character.isLowerCase(letter);
            letter = sentence.charAt(ind);
            
            if (up_case == true) {
                k += 1;
                
            } else if (up_case == false) {
                if (low_case == true) {
                        l += 1;
                        
                } else {
                }
                    
            } else {
            }
            ind += 1;
        }
        
        System.out.print("\nk. " + k);
        System.out.print("\nl. " + l);
        
        System.out.print("\nm. " + m);
        System.out.println("\n");
        
    }
}

我看到有人发布了答案。我会试一试，如果可行，我会勾选它。

Answer 3

另一种可能性是使用 regular expressions（您可能希望在继续学习时熟悉它 Java）。

测试数据

String[] data =
        { "boo", "hello", "vacuUm", "keenly", "weedprOof" };

模式。它会查找后跟相同元音的任何元音。

(?i:) 忽略匹配中的大小写。
([aeiou]) 是元音捕获组
(?=\1) 是先前匹配的元音的零宽度前瞻捕获块（所有这些都在上面的 link 中进行了解释）。

Pattern p = Pattern.compile("(?i:)([aeiou])(?=\1)");

现在只需遍历单词，为每个单词寻找一个或多个模式匹配项。这为找到的每一对打印一个字母，包括像 eee 这样的模式，这将是两对 e's

for (String d : data) {
    Matcher m = p.matcher(d);
    System.out.printf("%-10s -> ", d);
    boolean match = false;
    while (m.find()) {
        match = true;
        System.out.print(m.group(1) + " ");
    }
    System.out.println(match ? "" : "none found.");
}

或非正则表达式方法

String[] data =
        { "boo", "hello", "vacuUm", "keenly", "weedprOof" };

for (String d : data) {
    String orig = d;
    char[] chs = d.toLowerCase().toCharArray();
    System.out.printf("%-10s -> ", orig);
    boolean match = false;
    for (int i = 0; i < chs.length - 1; i++) {
        if ("aeiou".indexOf(chs[i]) >= 0) {
            if (chs[i] == chs[i + 1]) {
                match = true;
                System.out.print(chs[i] + " ");
            }
        }
    }
    System.out.println(match ? "" : "none found.");
    
}

同时打印

boo        -> o 
hello      -> none found.
vacuUm     -> u 
keenly     -> e 
weedprOof  -> e o

连续两次检查相同的元音

Check for same vowel twice in a row

java

string

char

switch-statement

java.util.scanner