如何计算多个字符串中 char 的出现次数？

Question

我的问题很特别，

给出这些字符串

          123456  
String1   ABCD
String2    BDD
String3     CDEF

我们可以看到

• 第 1 列中 A 的个数为 1。
• 第 2 列中 B 的数量为 2。
• 第 3 列中 C 的数量为 2。
• 第 3 列中 D 的数量为 1。
• 第 4 列中 D 的数量为 3。
• 第 5 列中 E 的数量为 1。
• 第 6 列中 F 的数量为 1。

这些计算的目的是获取在每列中出现最多的字符。

我可以用来处理这个问题的最佳 DataStructure 是什么？知道我只在执行时才知道每个字符串的长度。

我已经知道的信息是每个字符串开始的列的 n°。

我的想法和我认为这不是最好的想法是遍历列 n° 并计算每个字符出现了多少，最后找到出现次数最多的字符。

你有更好的解决方案吗？

info: 我的字符串只能包含那些 char[A,B,C,D,E,F] 谢谢。

Answer 1

通过这个示例代码，您可以将字符串作为列表插入，因此代码中的字符串数量不会受到任何限制，但会给出正确的输出。我在需要的地方添加了内联 cmets。

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class StringOperation {
public static void main(String[] args) {
    List<String> stringList=new ArrayList<String>();
    stringList.add("ABCD");
    stringList.add(" BDD");
    stringList.add("  CDEF");
    stringList.add("ABCD");

    char[][] array=getTwoDimentionArray(stringList);

    for (int i = 0; i < array.length; i++) {
        char[] cs = array[i];
        numberOfCharactorsinString(cs, i);

    }

}

//This method will create two dimension array from String list same time it will convert columns in to rows
public static char[][] getTwoDimentionArray(List<String> list){
    char[][] twoDimenArray=null;
    int maxLength=0;
    for (String strings : list) {
        if(maxLength<strings.length()){
            maxLength=strings.length();
        }               
    }
    twoDimenArray=new char[maxLength][list.size()];
    for (int i = 0; i < list.size(); i++) {
        char[] charArray=list.get(i).toCharArray();
        for (int j = 0; j < charArray.length; j++) {
            twoDimenArray[j][i] = charArray[j];             
        }           
    }

    return twoDimenArray;
}

//This method will return the char occurrences in the given char array
public static void numberOfCharactorsinString(char[] charArray,int count){

    //Here we use set to identify unique chars in the char array
    Set<Character> uniqueSet=new HashSet<Character>();
    int forcount=0;
    for (Character charVar : charArray) {
        int occurent=1;

        //check whether the searching char is not empty and not a space and not in previously counted
        if( charVar!=Character.MIN_VALUE && charVar!=' ' && !uniqueSet.contains(charVar) && forcount<charArray.length){
            uniqueSet.add(charVar);
            for (int x=forcount+1;x<charArray.length;x++ ) {
                if(charArray[x]==charVar){
                    occurent++;
                }
            }
            System.out.println("The number of "+charVar+" in column "+(count+1)+" is "+occurent+".");
        }
        forcount++;
    }
}
}

如果您提供输入（请注意，我已在此处的第 4 行添加了其他输入）

String1   ABCD
String2    BDD
String3     CDEF
String1   ABCD

输出如下

The number of A in column 1 is 2.
The number of B in column 2 is 3.
The number of C in column 3 is 3.
The number of D in column 3 is 1.
The number of D in column 4 is 4.
The number of E in column 5 is 1.
The number of F in column 6 is 1.

Answer 2

public class Main {
    public static void main(String[] args) {
        String str1 = "ABCD  ";
        String str2 = " BDD  ";
        String str3 = "  CDEF";
        String[] reversed = getReversed(str1, str2, str3);  // reverse rows with columns

        for(int i=0; i< reversed.length; i++){
            String trimedString = reversed[i].trim();  // removes spaces that around the string
            System.out.println(findMaxOccurrenceCharValue(trimedString));  // counts the maximum occurrence char
        }
    }

    private static String[] getReversed(String str1, String str2, String str3){
        char[] s1 = str1.toCharArray();
        char[] s2 = str2.toCharArray();
        char[] s3 = str3.toCharArray();

        String[] newStr = new String[6];
        for(int i =0; i<6; i++){
            newStr[i] = "" + s1[i] + s2[i] + s3[i];
        }
        return newStr;
    }

    private static String findMaxOccurrenceCharValue(String str) {
        char[] array = str.toCharArray();
        int[] count = new int[1000];
        for(char c: array){
            count[c]++;
        }

        // find the max occurrence character and number of occurrence
        String maxCharacter = "";
        int maxValue = -1;
        for(int i=0;i< array.length;i++){
            if(count[array[i]] > maxValue){
                maxValue = count[array[i]];
                maxCharacter = String.valueOf(array[i]);
            }
        }
        return  maxCharacter + "=" + maxValue;
    }
}

输出：

A=1
B=2
C=2
D=3
E=1
F=1