Question

大家好我想比较一个数组，我想打印位置[0]和[1]

之间的共同字母

在数组[0]中的示例我有类似[0] = aokk的东西在另一个位置，我有一个说[1] = ok;

我希望问题只打印位置0和位置的字母我正在做的是

for (int j = 0; j < a[0].length(); j++) {
    for (int i = 0; i < a[1].length(); i++) {
        if (a[0].charAt(i) == b[1].charAt(j)) {
            common += a[0].charAt(i);
        }
    }
}

但我得到的输出是“okk”，当它应该是“ok”时，因为K只在位置[0]

Answer 1

此算法的问题在于您要比较两个不同长度的字符串。在这种情况下，具有较短长度的字符串比另一个字符串更早地完成其循环，因此其索引保留在最后一个元素的较短的字符串，即＆＃34; k＆＃34;。另一个字符串，它的循环仍在继续，当它到达字母＆＃34; k＆＃34;时，你的if条件为真（因为＆＃34; k＆＃34; ==＆＃34; k＆＃34;）那就是为什么你会有双k。

Answer 2

尝试删除常见副本：

List<Character> list = new ArrayList<Character>();
for (char ch : common.toCharArray()) {
            list.add(ch);
}
return new HashSet<>(list).toString();

Answer 3

library(dplyr)
df1 %>%
  group_by(var1) %>%
  mutate(var2 = var2[var2!="x"][1])
#    var1  var2
#   <int> <chr>
#1      1     a
#2      2     a
#3      2     a
#4      3     b
#5      4     c
#6      5     a
#7      6     c
#8      6     c
#9      7     c
#10     8     b
#11     8     b
#12     8     b
#13     9     a

Answer 4

如果订购不重要，那么您可以使用以下代码。您可以对两个数组进行排序，然后更改合并排序以进行字符串中常见的比较。

public static String commonInArray(char[] char1, char[] char2) {
    int i = 0, j = 0;

    String common = "";

    while(i < char1.length) {
        if(char1[i] == char2[j]) {
            common += char1[i];
            i++;
            j++;
        } else if(char1[i] > char2[j]) {
            j++;
        } else {
            i++;
        }
    }

    return common;
} 

public static void main (String[] args) {
    // Strings in array for comparison
    String[] array = {"bitter","letter"};

    char[] char1 = array[0].toCharArray();
    Arrays.sort(char1);

    char[] char2 = array[1].toCharArray();
    Arrays.sort(char2);

    String common;

    if(char1.length > char2.length) {
        common = commonInArray(char1, char2);
    } else {
        common = commonInArray(char2, char1);
    }

    System.out.println(common);
}

替代解决方案：

1）将第一个字符串存储在链表

中

2）遍历第二个字符串

3）从链接列表中删除公共元素

    String[] a = {"aokk", "ok"};
    String common = "";

    LinkedList<Character> store = new LinkedList<Character>();

    for(int i = 0; i < a[0].length(); i++) {
        store.add(a[0].charAt(i));
    }

    for (int i = 0; i < a[1].length(); i++) {
        if(store.contains(a[1].charAt(i))) {
            common += a[1].charAt(i);
            store.remove(store.indexOf(a[1].charAt(i)));
        }
    }

    System.out.println(common);

Answer 5

以下是您的需求：

import java.util.ArrayList;
import java.util.List;

class Solution{
    public static void main(String args[]){
        String arr[] = {"aokk","ok"};
        List<Integer> index = new ArrayList<Integer>();
        for(int i=0;i<arr[0].length();i++){
            for(int j=0;j<arr[1].length();j++){
                if(arr[0].charAt(i)==arr[1].charAt(j) && index.contains(j)==false){
                    System.out.print(arr[0].charAt(i)); //print if it matches
                    index.add(j);//add index to list so it won't count again
                    break;
                }
            }
        }
    }
}

Answer 6

试试这个：

1.Assuming in your case,that in String array , a[0] has maximum length
2.Of course, you can get the maximum length from the string array you can choose the max length and you can modify the length and do according to your requirement.                                
3. For now, check the following :

public static void main(String[] args) 
{

String a[]={"aokk","ok"};
String common = "";
 for(int i=0;i < a[1].length();i++)
 {
  for(int j=0; j<a[0].length();j++) 
  {
    if(a[1].charAt(i) == a[0].charAt(j) && common.indexOf(a[0].charAt(j))<0)
    {
       common = common + a[0].charAt(j);
    }
  }
 }
  System.out.println(common);
}

Answer 7

已经有很多可爱的解决方案，每个解决方案都有自己的优点和缺点。我会提出我的建议。我假设字母的顺序并不重要，但如果每个字符串中出现两次字母，则结果中也必须出现两次。

/** @return chars common to a[0] and a[1] */
public static String commonChars(String[] a) {
    int[] charCounts = new int[256];
    for (int index = 0; index < a[0].length(); index++) {
        charCounts[a[0].charAt(index)]++;
    }
    StringBuilder result = new StringBuilder(a[0].length());
    for (int index = 0; index < a[1].length(); index++) {
        if (charCounts[a[1].charAt(index)] > 0) {
            result.append(a[1].charAt(index));
            charCounts[a[1].charAt(index)]--;
        }
    }
    return result.toString();
}

我自己判断的优势：考虑到一封信可能会出现两次（如按钮和黄油，或字母和苦味）。相当高效（这可能无关紧要）。如果重要，这些字母通常按照a[1]中的顺序排列。

弱点我知道：如果任一字符串包含Latin-1范围之外的字符（0到255）或ArrayIndexOutOfBoundsException小于2，则使用a进行分解。

Java数组字符串比较

7 个答案: