在两个数组之间查找不匹配整数的方法中的错误

Question

我正在尝试在下面的 java 代码中执行以下功能：我正在尝试生成在“匹配”数组和“原始”数组之间不匹配的整数数组。

为此，我创建了一个子数组类，该类允许我获取两个数组（匹配和原始）中其余不匹配的元素，最后，我有一个名为 match_sequence 的类来完成这项工作。

我的问题是函数中存在一个我不知道为什么的错误，例如，如果我的输入是 int[] original = {1,0}; int[] 匹配 = {1,0};当它应该是 [] 时，我得到原始和匹配 [0] 的残差，如果我的输入是 {1,0,0}，{1,0,0}，则没有这样的问题，但如果我的输入都是 {1,0,1,0,0}，我在两个元素中都得到了 [0, 0] 作为不匹配的数组，再一次，结果应该是 [] 因为它们是完全匹配的数组。

这让我发疯了，谁能告诉我错误在哪里？

import java.util.Arrays;
 
public class subarray
{
    // Generic method to get subarray of a non-primitive array
    // between specified indices
    public static<T> int[] subArray(int[] arr, int beg, int end) {
        return Arrays.copyOfRange(arr, beg, end+1);
    }
}

import java.util.Arrays;

public class results {     
      private int[] array1; //array2
      private int[] array2; //array1

      public results (int[] result1, int[] result2)
      {
         array1 = result1;
         array2 = result2;
         //return results(array1,array2);
      }
      public int[] getArray1() { return array1; }
      public int[] getArray2() { return array2; }
}

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class match_sequence {
    
    public static results match_sequence(int[] original_rest,int[] match)  {

        if(match.length <= original_rest.length) {
            for (int j = 0; j < match.length; j++) {
                //set a initial starting point plus i if we are not starting from 0
                if (original_rest[j]==match[j]) {
                    match = subarray.subArray(match,j+1,match.length-1);
                    original_rest = subarray.subArray(original_rest,j+1,original_rest.length-1);
                } else if (original_rest[j]!=match[j]) {
                    original_rest = subarray.subArray(original_rest,j,original_rest.length-1);
                    match = subarray.subArray(match,j,match.length-1);
                    if(original_rest[0]!=match[0]){
                        System.out.println("This is not an interweave of two sub elements!");
                    }
                    break;
                }
            }
        }
        if(match.length > original_rest.length) {
            for (int j = 0; j < original_rest.length; j++) {
                //set a initial starting point plus i if we are not starting from 0
                if (original_rest[j]==match[j]) {
                    match = subarray.subArray(match,j+1,match.length-1);
                    original_rest = subarray.subArray(original_rest,j+1,original_rest.length-1);
                } else if (original_rest[j]!=match[j]) {
                    original_rest = subarray.subArray(original_rest,j,original_rest.length-1);
                    match = subarray.subArray(match,j,match.length-1);
                    if(original_rest[0]!=match[0]) {
                        System.out.println("This is not an interweave of two sub elements!");
                    }
                    break;
                }
            }
        }

        return new results(match,original_rest);
    }
    //here is the problem:  
    public static void main(String[] args)
    {
        int[] original = {1,0};
        int[] match = {1,0};
        //bug1: there is mismatch over here and should be resolved through debugging
        int[] rest_of_match = match_sequence(original,match).getArray1();
        System.out.println("Final match"+Arrays.toString(rest_of_match));
        int[] original_rest = match_sequence(original,match).getArray2();
        System.out.println("Final original"+Arrays.toString(original_rest));
    }
}

Answer 1

问题出在match_sequence() 方法内部。您对数组的第一个元素进行切片，但不会将 j 索引向后移动。为此，在 for 循环的末尾添加这样的行：

j--;

还 match_sequence() 包含大量代码重复。如果语句是多余的，您可以将它们组合在一个 for 循环中：

public static results match_sequence(int[] original_rest, int[] match) {
    for(int j = 0; j < Math.min(match.length, original_rest.length); j++) {
        //set a initial starting point plus i if we are not starting from 0
        if(original_rest[j] == match[j]) {
            match = subarray.subArray(match, j + 1, match.length - 1);
            original_rest = subarray.subArray(original_rest, j + 1, original_rest.length - 1);
        } else if(original_rest[j] != match[j]) {
            original_rest = subarray.subArray(original_rest, j, original_rest.length - 1);

            match = subarray.subArray(match, j, match.length - 1);
            if(original_rest[0] != match[0]) {
                System.out.println("This is not an interweave of two sub elements!");
            }
            break;
        }
        j--;
    }

    return new results(match, original_rest);
}

输出：

Final match[]
Final original[]

更新：
下图显示了为什么需要将j 移回。如果您不这样做，那么您将跳过列表的第二个元素。