比较java中的两个数组并返回相等数

我目前正在编写一个小函数，它应该返回一个数组中有多少项与另一个数组完全位于同一位置，有多少项位于不同位置

该函数当前看起来如下所示：

public static int[] numCorrects(char[] leftarray, char[] rightarray){
    int counter[] = new int[2];
    counter[0] = 0;
    counter[1] = 0;

    for (int i = 0; i < leftarray.length; i++) {
        if(leftarray[i]==rightarray[i]) counter[0]++;
        else {
            for (int n = 0; n < leftarray.length; n++) {
                if (leftarray[i] == rightarray[n] && leftarray[n] != rightarray[n]) {
                    counter[1]++;
                    break;
                }
            }
        }
    }
    return counter;
}

public static int[]numCorrects（char[]leftarray，char[]righArray）{
整数计数器[]=新整数[2]；
计数器[0]=0；
计数器[1]=0；
for（int i=0；i

如果我有

（1,2,3,4）

的

leftarray

和

（4,3,2,2）

它返回

（0，3）

（0精确匹配，3在不同位置）

但现在的问题是：

如果我用

（4，3，2，2）

的

左数组

和

（1，2，3，4）

的

右数组

交换输入，则输出是

（0，4）

，这是错误的（应该与第一个相同）

---

希望有人能帮助我。thx

您必须决定如何处理重复元素。这就是造成差异的原因。重复的

2

表示在交换阵列时，“不同位置”计数器将增加两次。

您必须决定如何处理重复的元素。这就是造成差异的原因。重复的

2

表示在交换阵列时，“不同位置”计数器会增加两次。

尝试以下操作：

public static int[] numCorrects(char[] leftarray, char[] rightarray){
    int counter[] = new int[2];
    counter[0] = 0;
    counter[1] = 0;
    boolean taken[] = new boolean[rightarray.length];
    for (int i=0;i<taken.length;i++)
        taken[i] = false;

    for (int i = 0; i < leftarray.length; i++) {
        if(leftarray[i]==rightarray[i]){ counter[0]++; taken[i] = true; }
        else {
            for (int n = 0; n < leftarray.length; n++) {
                if (leftarray[i] == rightarray[n] && leftarray[n] != rightarray[n] && !taken[n]) {
                    taken[n] = true;
                    counter[1]++;
                    break;
                }
            }
        }
    }
    return counter;
}

public static int[]numCorrects（char[]leftarray，char[]righArray）{
整数计数器[]=新整数[2]；
计数器[0]=0；
计数器[1]=0；
boolean take[]=新的boolean[rightarray.length]；
对于（int i=0；i请尝试以下方法：

public static int[] numCorrects(char[] leftarray, char[] rightarray){
    int counter[] = new int[2];
    counter[0] = 0;
    counter[1] = 0;
    boolean taken[] = new boolean[rightarray.length];
    for (int i=0;i<taken.length;i++)
        taken[i] = false;

    for (int i = 0; i < leftarray.length; i++) {
        if(leftarray[i]==rightarray[i]){ counter[0]++; taken[i] = true; }
        else {
            for (int n = 0; n < leftarray.length; n++) {
                if (leftarray[i] == rightarray[n] && leftarray[n] != rightarray[n] && !taken[n]) {
                    taken[n] = true;
                    counter[1]++;
                    break;
                }
            }
        }
    }
    return counter;
}

public static int[]numCorrects（char[]leftarray，char[]righArray）{
整数计数器[]=新整数[2]；
计数器[0]=0；
计数器[1]=0；
boolean take[]=新的boolean[rightarray.length]；
对于（int i=0；i删除中断将得到相同的结果。
删除中断将得到相同的结果。
公共静态int[]numCorrects（char[]leftarray，char[]righarray）{
public static int[] numCorrects(char[] leftarray, char[] rightarray){
    int counter[] = new int[2];
    counter[0] = 0;
    counter[1] = 0;
    boolean taken[] = new boolean[rightarray.length];
    for (int i=0;i<taken.length;i++)
        taken[i] = false;

    for (int i = 0; i < leftarray.length; i++) {
        if(leftarray[i]==rightarray[i])
        {
            counter[0]++;
            taken[i]=true;
        }
    }

    for (int i = 0; i < leftarray.length; i++)
    {
        if (!taken[i])
        {
            for (int j = 0; j < rightarray.length; j++) {
                if (leftarray[i] == rightarray[j] && i!=j && !taken[j]) { // you can remove i!=j because its already don't apply because of !taken[i]
                    taken[j] = true;
                    counter[1]++;
                    break;
                }
            }
        }
    }
    return counter;
}

整数计数器[]=新整数[2]；
计数器[0]=0；
计数器[1]=0；
boolean take[]=新的boolean[rightarray.length]；
对于（int i=0；i
公共静态int[]numCorrects（char[]leftarray，char[]rightarray）{
整数计数器[]=新整数[2]；
计数器[0]=0；
计数器[1]=0；
boolean take[]=新的boolean[rightarray.length]；
对于（int i=0；iYou可以释放leftarray[n]！=rightarray[n]，您之前已经检查过同一索引上的元素是否相同。考虑到您在那段代码中，它们不相同。您可以释放leftarray[n]！=rightarray[n]，您之前已经检查过同一索引上的元素是否相同。考虑到您在这段代码中，它们不是。我编辑了代码。要设置if（leftarray[I]==righArray[I]），请稍候，这是错误的。我们必须单独使用循环（同一位置）执行第一种情况。然后循环中的另一个案例。让我修复。我添加了另一个答案。检查它。它更符合逻辑。它更长，但您可以稍后减少长度。如果另一个答案正确，我们可以删除此答案。ok hmm尝试了它。它修复了给定示例中的问题。但如果第一个数组类似于
（2，2，2，5），则不会
和第二个类似
（1，2，2，4）
我得到了类似
（1，2）
的东西，应该是
（0，2）
（2，2，5）（1，2，2，4）应该给出（2，0）和其他代码所做的。2在同一个位置，0不在同一个位置。我编辑了代码。设置if（leftarray[i]==righArray[i]）等等，这是错误的。我们必须单独使用循环（相同的位置）执行第一个案例。然后循环中的另一个案例。让我修复。我添加了另一个答案。检查它。它更符合逻辑。它更长，但您可以稍后减少长度。如果另一个答案正确，我们可以删除此答案。ok hmm尝试了它。它修复了给定示例中的问题。但如果第一个数组类似于
（2，2，2，5），则不会
和第二个类似
（1,2,2,4）
我得到了类似
（1,2）
的东西，应该是
（0,2）
（2,2,5）（1,2,2,4）应该是（2,0）这就是其他代码所做的。2在同一个位置，0不在同一个位置。是的，无论输入顺序如何，结果都是相同的，但两个时间都不正确。如果数组的长度仅为4，则匹配项不能超过4个。如果没有中断，它将对一些值进行两次计数。然后，您应该实现一种方法来检查是否已经有进程将处理后的数字放入HashMap或类似的东西中，在将其与另一个数组进行比较之前，检查该数字是否不在HashMap中。是的，无论输入顺序如何，结果都是相同的，但两次都不正确。如果数组长度仅为4，则匹配数不能超过4个。如果不中断，它将uld对一些值进行两次计数。然后你应该实现一种方法来检查你之前是否已经处理过该数字。将处理过的数字放入哈希映射或类似的东西中，在将其与其他数组进行比较之前，检查该数字是否还不在哈希映射中。我假设你正在实现那个流行的游戏。想知道我的意思吗尝试以下两个答案：1 13 4和5 1 6 7。检查这两个代码，然后你决定。如果这项工作接受这一个并进行投票。我将删除另一个。我假设你正在实现那个流行的游戏。要知道我的意思，请尝试以下两个答案：1 13 4和5 1 6 7。检查这两个代码，然后你决定。如果这是我接受这一点，投赞成票。