Question

我遇到了这个问题。所有的答案都会检查所有的电话，除了一个我没有得到的电话。

当它应该为真时，

contains({1, 2, 1, 2, 3}, {1, 2, 3})返回false。

提示：

编写一个名为contains的静态方法，它接受两个整数a1和a2数组作为参数，并返回一个布尔值，指示a2的元素序列是否出现在a1（如果是，则为true，否则为false）。 a2中的元素序列可能出现在a1中的任何位置，但必须以相同的顺序连续出现。例如，如果名为list1和list2的变量存储以下值：

int[] list1 = {1, 6, 2, 1, 4, 1, 2, 1, 8};
int[] list2 = {1, 2, 1};

然后对contains（list1，list2）的调用应返回true，因为list2的值序列{1, 2, 1}包含在list1中的list1中。如果list2存储了值{2, 1, 2}，则调用contains（list1，list2）将返回false，因为list1不包含该值序列。具有相同元素的任何两个列表被认为彼此包含，因此诸如contains（list1，list1）之类的调用应该返回true。

您可以假设传递给您的方法的两个数组的长度至少为1.您可能不会使用任何字符串来帮助您解决此问题，也不会使用生成字符串的方法，例如Arrays.toString。

代码：

public static boolean contains(int[] first, int[] second) {
    int secondCount = 0; // Indicates where to start on second array

    if (first.length < second.length) { // If second array is longer than first
        return false;
    }

    for (int i=0; i<first.length; i++) { // goes through each element in first array
        if (first[i] == second[secondCount]) { // If elements match 
            secondCount++; // increment by one and move onto next elem on second
            if (secondCount == second.length) { // If complete match
                return true;
            }
        } else { // resets count
            secondCount = 0;
        }
    }
    return false;
}

Answer 1

由于构建循环的方式，您的方法返回false。下面，我概述了方法的运行时间。

i = 0; secondCount = 0;
{1, 2, 1, 2, 3} {1, 2, 3}
 ^               ^
 1 == 1 ? true

i = 1; secondCount = 1;
{1, 2, 1, 2, 3} {1, 2, 3}
    ^               ^
 2 == 2 ? true

i = 2; secondCount = 2;
{1, 2, 1, 2, 3} {1, 2, 3}
       ^               ^
 1 == 3 ? false

i = 3; secondCount = 0;
{1, 2, 1, 2, 3} {1, 2, 3}
          ^      ^
 2 == 1 ? false

i = 3; secondCount = 0;
{1, 2, 1, 2, 3} {1, 2, 3}
             ^   ^
 3 == 1 ? false

return false;

问题是，如果布尔方程first[i] == second[secondCount]为假，则{strong} secondCount仍然高级时会重置i。因此，contains({1, 2, 1, 2, 3}, {1, 2, 3});将始终返回false。

每当continue无法阻止first[i] == second[secondCount]推进时，请考虑在代码中添加i。

Answer 2

将secondCount从非零重置为零时，也会将i减1。

Answer 3

工作代码 - ＆gt;

public static boolean contains(int[] first, int[] second) {
int secondCount = 0; // Indicates where to start on second array

if (first.length < second.length) { // If second array is longer than first
    return false;
}

for (int i=0; i<first.length; i++) { // goes through each element in first array
    if (first[i] == second[secondCount]) { // If elements match 
        secondCount++; // increment by one and move onto next elem on second
        if (secondCount == second.length) { // If complete match
            return true;
        }
    } else { // resets count
        secondCount = 0;
        i--;          //ADD THIS
    }
}
return false;
}

（使用list1的例子= {1,2,1,2,3}和list2 = {1,2,3}）＆＃39; i＆＃39;必须递减，因为当最初list1 [0]和list1 [1]分别等于list2 [0]和list2 [1]并且list1 [2]的比较是list2 [2]，这是假的，你只减少第二次计数，你做i ++，因此当你再次开始时，你将list1 [3]与list2 [0]进行比较，这是假的，但你应该比较list1 [2]而不是list1 [3]。

Answer 4

我看过很多类似于我的代码，但我认为这是一个更好的解决方案！

public static void main(String[] args){
        int[] list1 = {1, 6, 2, 1, 4, 1, 2, 1, 8};
        int[] list2 = {1, 2, 1};
        boolean presence = contains(list1, list2);
        System.out.println(presence);
}

public static boolean contains(int[] list1, int[] list2){
    if (list1.length < list2.length){
        return false;
    }
    int count = 0;
    int counter = 0;
    for (int i = 0; i < list1.length; i++){
        if (list1[i] == list2[counter]){
            count++;
            counter++;
            if (count == list2.length){
                return true;
            }
        }else{
            counter = 0;
        }
    }
    return false;
}

在数组中查找连续匹配元素

4 个答案: