(Java) 计算句子中的字母？

问题描述 投票：0回答：8

以下是我的代码：

char[] array = new char[26] ;

    int index = 0 ;
    int letter = 0 ;
    int countA = 0 ;

    String sentence = "Once upon a time..." ;

    if(sentence.contains("."))
    {
        String sentenceNoSpace = sentence.replace(" ", "").toLowerCase() ;
        String sentenceFinal = sentenceNoSpace.substring(0, sentenceNoSpace.indexOf(".")) ;
        char[] count = new char[sentenceFinal.length()] ;
        for (char c = 'a'; c <= 'z'; c++) 
        {
            array[index++] = c ;
            for(int i = 0; i < sentenceFinal.length(); i++)
            {
                if(sentenceFinal.charAt(i) == c)
                    count[letter++] = c ; 
                //if(sentenceFinal.charAt(i) == 'a')    
                    //countA++ ;   
            }

        }
        String result = new String(count) ; // Convert to a string.
        System.out.println("\n" + result) ;

        System.out.println("\nTotal number of letters is " + result.length()) ;
        System.out.println(countA) ;
    }
    else
    {
       System.out.println("You forgot a period. Try again.") ;
    }

我无法计算给定句子中有多少个 a、b、c 等。我有一种方法可以做到，就是这一部分 

//if(sentenceFinal.charAt(i) == 'a')    
                //countA++ ;

我可以一直创建到 z。有没有更有效的方法？

注意：不要使用 Hashmap 或任何其他高级技术。

java arrays char counting
8个回答
2
投票

无需消除空格。这只是您正在做的额外工作。

int countOfLetters = 0 ;
String sentence = "Once upon a time..." ;
sentence = sentence.toLowerCase();
int[] countOfAlphabets = new int[26];
for (int i = 0; i < sentence.length(); i++) {
    if (sentence.charAt(i) >= 'a' && sentence.charAt(i) <= 'z') {
        countOfAlphabets[sentence.charAt(i) - 97]++;
        countOfLetters++;
    }
}

因此，

countOfLetters
将为您提供字母总数。 如果您想要单独计数，假设您想要计算 'c',

您可以通过访问

countOfAlphabets
数组来获取它，例如
countOfAlphabets['c' - 97]
（97是'a'的ASCII值）

1
投票

使用 

int
数组 
letterCounts
来存储每个字母的计数。假设可以忽略字母的大小写，则 
letterCounts
数组的长度将为 26。

迭代字符串的字符并更新数组中相应的整数。使用其 ASCII 值查找对应的索引，如下所示。 

letterCounts[c - 97]++

97 是 'a' 的 ASCII 值，其计数需要存储在索引 0 处。

这样，从字符的 ASCII 值中减去 97 就可以得到该字符对应的索引。

注意：这是假设您要存储小写字母的计数。

0
投票

在不使用映射的情况下相当繁琐，但这会计算字符串中的所有字符。

您可能需要修改以排除空格等内容。

public class Main {

    public static void main(String[] args) {
        String sentence = "Once upon a time...";

        // Create an array of size 256 ASCII_SIZE
        int count[] = new int[256];
        int length = sentence.length();

        // Initialize count array index
        for (int i = 0; i < length; i++)
            count[sentence.charAt(i)]++;

        // Create an array of given String size
        char chars[] = new char[sentence.length()];
        for (int i = 0; i < length; i++) {
            chars[i] = sentence.charAt(i);
            int find = 0;
            for (int j = 0; j <= i; j++) {

                // If any matches found
                if (sentence.charAt(i) == chars[j])
                    find++;
            }

            if (find == 1) {
               System.out.println("Occurrence of " + sentence.charAt(i) + " is:" + count[sentence.charAt(i)]);

            }
        }
    }
}

哪个输出：

Occurrence of O is:1
Occurrence of n is:2
Occurrence of c is:1
Occurrence of e is:2
Occurrence of   is:3
Occurrence of u is:1
Occurrence of p is:1
Occurrence of o is:1
Occurrence of a is:1
Occurrence of t is:1
Occurrence of i is:1
Occurrence of m is:1
Occurrence of . is:3
0
投票

检查下面的代码您可以有一个 26 长度的数组，索引将根据字母表的存在而递增。

public void getResult(){

        int [] charCount = new int [26];
        int countA = 0 ;

        String sentence = "Once upon a time..." ;

        if(sentence.contains("."))
        {
            String sentenceNoSpace = sentence.replace(" ", "").toLowerCase() ;
            String sentenceFinal = sentenceNoSpace.substring(0, sentenceNoSpace.indexOf(".")) ;

            char[] sentenceCharArray = sentenceFinal.toCharArray();
            //char a = 97;
            for (int i = 0; i <sentenceCharArray.length ; i++) {
                int index = sentenceCharArray[i] - 97 ;
                if(index >= 0 && index <= 26) {
                    charCount[index] += 1;
                }
            }


            System.out.print("Result : ");

            for (int i = 0; i < charCount.length ; i++) {
                System.out.print(charCount [i]+" , ");
            }


            System.out.println("\nTotal number of letters is " + sentenceCharArray.length) ;
        }
        else
        {
            System.out.println("You forgot a period. Try again.") ;
        }
    }
0
投票

由于美国字母表中有 26 个字母，因此您可以使用大小为 26 的 

int[]

int[] letterCount = new int[26];

保存每个字母的计数，其中索引 0 代表“a”，1 代表“b”等...

当您遍历句子时，检查您所在的字符是否是字母，

Character.isLetter()
，然后递增数组中表示该字母的元素。

letterCount[letter - 'a']++;

我们从字母中减去“a”以获得正确的索引。

代码示例

package stackoverflow;

public class Question {

    public static void main(String[] args) {
        String sentence = "The quick brown fox jumps over the lazy dog.";
        int[] letterCount = new int[26];
        if (sentence.contains(".")) {
            // toLowerCase() the sentence since we count upper and lowercase as the same
            for (char letter : sentence.toLowerCase().toCharArray()) {
                if (Character.isLetter(letter)) {
                    letterCount[letter - 'a']++;
                }
            }

            // Display the count of each letter that was found
            int sumOfLetters = 0;
            for (int i = 0; i < letterCount.length; i++) {
                int count = letterCount[i];
                if (count > 0) {
                    System.out.println((char)(i + 'a') + " occurs " + count + " times");
                    sumOfLetters += count;
                }
            }

            System.out.println("Total number of letters is " + sumOfLetters);
        } else {
            System.out.println("You forgot a period.  Try again.");
        }
    }
}

结果

a occurs 1 times
b occurs 1 times
c occurs 1 times
d occurs 1 times
e occurs 3 times
f occurs 1 times
g occurs 1 times
h occurs 2 times
i occurs 1 times
j occurs 1 times
k occurs 1 times
l occurs 1 times
m occurs 1 times
n occurs 1 times
o occurs 4 times
p occurs 1 times
q occurs 1 times
r occurs 2 times
s occurs 1 times
t occurs 2 times
u occurs 2 times
v occurs 1 times
w occurs 1 times
x occurs 1 times
y occurs 1 times
z occurs 1 times
Total number of letters is 35

反驳问题

使用 Java 8 并使用 

chars()
的 
String
有什么问题吗？ 有了它，您可以用更少的代码完成同样的事情。 对于字母总数，我们只需使用 
String.replaceAll()
并使用模式 
String
从 
[^A-Za-z]
中删除所有非字母，然后使用结果的 
length()
。

package stackoverflow;

import java.util.function.Function;
import java.util.stream.Collectors;

public class Question {

    public static void main(String[] args) {
        String sentence = "The quick brown fox jumps over the lazy dog.";

        System.out.println(sentence.toLowerCase().chars()
            // Change the IntStream to a stream of Characters
            .mapToObj(c -> (char)c)
            // Filter out non lower case letters
            .filter(c -> 'a' <= c && c <= 'z')
            // Collect up the letters and count them
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting())));

        System.out.println("Total letter count is " + sentence.replaceAll("[^A-Za-z]", "").length());               
    }
}

结果

{a=1, b=1, c=1, d=1, e=3, f=1, g=1, h=2, i=1, j=1, k=1, l=1, m=1, n=1, o=4, p=1, q=1, r=2, s=1, t=2, u=2, v=1, w=1, x=1, y=1, z=1}
Total letter count is 35
0
投票

你可以用正则表达式解决它，如果

Regex
不会被认为是高科技🙂

想法很简单：删除所有字母并从原始字符串长度中减去输出以获得计数器

String sentence = "Once upon a time...";
String noLetterString = sentence.replaceAll("[a-zA-Z]", "");
int counterLetter = sentence.length() - noLetterString.length();
System.out.println("counter:" + counterLetter);

通过老派编程🙂 这里的想法是相反的，只附加字母

String sentence = "Once upon a time...";
String lowerCase = sentence.toLowerCase(); // to avoid comparison to UpperCase letters
StringBuilder counterStr = new StringBuilder();
for (char l : lowerCase.toCharArray()) {
    if (l >= 'a' && l <= 'z') {
        counterStr.append(l);
    }
}

System.out.println("counterStr:" + counterStr);
System.out.println("counter:" + counterStr.length());
0
投票

获取句子中连续字母的数量。

公共类 CountNumberOfLettersInContinous {

public static void main(String[] args) {

    String word = "aAcbbbaffkkkkd";

    int i = 0;
    int counter = 1;
    String counterString = "";
    System.out.println("Started");

    while (i < word.length()) {

        if (i == word.length() - 1) {
            counterString = counterString + word.charAt(i) + counter;
            System.out.println(counterString);
            break;

        }

        if (String.valueOf(word.charAt(i)).equalsIgnoreCase(String.valueOf(word.charAt(i + 1)))) {
            counter++;

        } else {
            counterString = counterString + word.charAt(i) + counter;
            counter = 1;
        }
        i++;
    }

}

}

-1
投票

这是更新代码：

int[] array = new int[26] ;

    String sentence = "Once upon a time..." ;

    if(sentence.contains("."))
    {
        String sentenceNoSpace = sentence.replace(" ", "").toLowerCase() ;
        String sentenceFinal = sentenceNoSpace.substring(0, sentenceNoSpace.indexOf(".")) ;

        for (char c : sentenceFinal.toCharArray()) 
        {
            System.out.println(c+"  "+(c-97)); 
            array[c-97] += 1;     
        }

      // System.out.println("\n" + Arrays.toString(array)) ;

        for(int i=0; i< array.length;i++) {

            if(array[i] != 0) {

            char c = (char)(i+97);
            System.out.println(c+" occured "+ array[i]+" times");
          }
        }
    }
    else
    {
       System.out.println("You forgot a period. Try again.") ;
    }
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.