Question

我试图创建一个函数，该函数打印给定n个字符串中常见的字符数。（请注意，字符可以多次使用）

我正在努力对n个字符串执行此操作，但是我对2个字符串做到了这一点，而且没有重复重复任何字符。

我已经发布了我的代码。

public class CommonChars {

    public static void main(String[] args) {
        String str1 = "abcd";
        String str2 = "bcde";
        StringBuffer sb = new StringBuffer();
        // get unique chars from both the strings

        str1 = uniqueChar(str1);
        str2 = uniqueChar(str2);
        int count = 0;
        int str1Len = str1.length();
        int str2Len = str2.length();

        for (int i = 0; i < str1Len; i++) {

            for (int j = 0; j < str2Len; j++) {

                // found match stop the loop
                if (str1.charAt(i) == str2.charAt(j)) {
                    count++;
                    sb.append(str1.charAt(i));
                    break;
                }
            }

        }   
        System.out.println("Common Chars Count : " + count + "\nCommon Chars :" + 
        sb.toString());
    }


    public static String uniqueChar(String inputString) {
        String outputstr="",temp="";
        for(int i=0;i<inputstr.length();i++) {
            if(temp.indexOf(inputstr.charAt(i))<0) {
                temp+=inputstr.charAt(i);
            }
        }
        System.out.println("completed");
        return temp;
    }

}

3 
abcaa
bcbd
bgc
3

他们可能会多次在同一个角色中出现一个字符串，您不应该消除这些字符检查编号有时它们会在其他字符串中重复出现。例如

 3
 abacd
 aaxyz
 aatre

输出应为2

如果我能用Java解决方案，那就更好了

Answer 1

针对您的问题的更好策略是使用此方法：

public int[] countChars(String s){
    int[] count = new int[26];
    for(char c: s.toCharArray()){
        count[c-'a']++;
    }
    return count;
}

现在，如果您有n个字符串（String []个字符串），只需找到每个字母的共同字符的最小值：

int[][] result = new int[n][26]
for(int i = 0; i<strings.length;i++){
    result[i] = countChars(s);
}
// now if you sum the min common chars for each counter you are ready
int commonChars = 0; 
for(int i = 0; i< 26;i++){
    int min = result[0][i];
    for(int i = 1; i< n;i++){
        if(min>result[j][i]){
            min = result[j][i];
        }
    }
    commonChars+=min;
}

Answer 2

获取每个字符串的字符列表：

List<Character> chars1 = s1.chars()    // list of chars for first string
            .mapToObj(c -> (char) c)
            .collect(Collectors.toList());

List<Character> chars2 = s2.chars()    // list of chars for second string
            .mapToObj(c -> (char) c)
            .collect(Collectors.toList());

然后使用retainAll方法：

chars1.retainAll(chars2);  // retain in chars1 only the chars that are contained in the chars2 also
System.out.println(chars1.size());

如果要获取唯一字符数，请使用Collectors.toSet()代替toList()

Answer 3

好吧，如果有人去做哈希：

public static int uniqueChars(String first, String second) {
    boolean[] hash = new boolean[26]; 
    int count = 0;
    //reduce first string to unique letters
    for (char c : first.toLowerCase().toCharArray()) {
        hash[c - 'a'] = true;
    }
    //reduce to unique letters in both strings
    for(char c : second.toLowerCase().toCharArray()){
        if(hash[c - 'a']){
            count++; 
            hash[c - 'a'] = false;
        }
    }
    return count;
}

这使用的是bucketsort，其复杂度为n + m，但需要26个bucket（“ hash”数组）。 Imo在复杂性方面不能做得更好，因为您需要至少查看一次每个字母，总计n + m。

最好的方法是将imho放在O（n log（n））范围内。

您的方法是在O（n²）联盟中的某个地方

附件：如果您需要字符作为字符串（本质上与上面相同，count是返回的字符串的长度）：

public static String uniqueChars(String first, String second) {
    boolean[] hash = new boolean[26]; 
    StringBuilder sb = new StringBuilder();
    for (char c : first.toLowerCase().toCharArray()) {
        hash[c - 'a'] = true;
    }
    for(char c : second.toLowerCase().toCharArray()){
        if(hash[c - 'a']){
            sb.append(c);
            hash[c - 'a'] = false;
        }
    }
    return sb.toString();
}

Answer 4

public static String getCommonCharacters(String... words) {
    if (words == null || words.length == 0)
        return "";

    Set<Character> unique = words[0].chars().mapToObj(ch -> (char)ch).collect(Collectors.toCollection(TreeSet::new));

    for (String word : words)
        unique.retainAll(word.chars().mapToObj(ch -> (char)ch).collect(Collectors.toSet()));

    return unique.stream().map(String::valueOf).collect(Collectors.joining());
}

另一个变种，无需创建临时Set并使用Character。

public static String getCommonCharacters(String... words) {
    if (words == null || words.length == 0)
        return "";

    int[] arr = new int[26];
    boolean[] tmp = new boolean[26];

    for (String word : words) {
        Arrays.fill(tmp, false);

        for (int i = 0; i < word.length(); i++) {
            int pos = Character.toLowerCase(word.charAt(i)) - 'a';

            if (tmp[pos])
                continue;

            tmp[pos] = true;
            arr[pos]++;
        }
    }

    StringBuilder buf = new StringBuilder(26);

    for (int i = 0; i < arr.length; i++)
        if (arr[i] == words.length)
            buf.append((char)('a' + i));

    return buf.toString();
}

演示

System.out.println(getCommonCharacters("abcd", "bcde"));  // bcd

Answer 5

您必须将Tj中的所有df1转换为df3 = df2.copy() df3.loc[235,'arg_1'] = df1.loc[df1.event_id == df2.loc[235,'arg_1'], 'token_name'].iloc[0] df3.loc[235,'arg_2'] = df1.loc[df1.event_id == df2.loc[235,'arg_2'], 'token_name'].iloc[0] df3.loc[236,'arg_1'] = df1.loc[df1.event_id == df2.loc[236,'arg_1'], 'token_name'].iloc[0] df3.loc[236,'arg_2'] = df1.loc[df1.event_id == df2.loc[236,'arg_2'], 'token_name'].iloc[0]，并保留第一个中的所有内容。下面的解决方案有很多地方可以优化，但是您应该了解总体思路。

String

上面的代码显示：

Set

n个字符串中的常见字符

5 个答案: