Question

任务是找到不连续的数组的第一个元素。

E.g。如果我们有一个数组[1,2,3,4,6,7,8]那么1然后是2然后是3然后4都是连续的但是6不是，所以这是第一个非连续的数字。

如果整个数组是连续的，则返回null

这是我的解决方案：

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

class FirstNonConsecutive {

    private static int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
    private static List<Integer> list = new ArrayList<Integer>();


    private static Integer[] arrtwovalues = new Integer[arr.length];
    private static Integer solve;


    static Integer find(final int[] array) {
        int[] temp = new int[array.length];
        int possition = array[0];


        for (int i = 0; i < array.length - 1; i++) {
            temp[i] = array[i + 1];
        }


        for (int i = 0; i < temp.length; i++) {
            if (temp[i] == 0) {
                temp[i] = possition;
            }
        }

        for (int i = 0; i < array.length; i++) {
            if (temp[i] - array[i] == 2) {
                arrtwovalues[i] = temp[i];
            }
        }


        for (int i = 0; i < array.length; i++) {
            if (temp[i] - array[i] == 2) {
                arrtwovalues[i] = temp[i];
            }
        }
        int counter = 0;
        for (int i = 0; i < arrtwovalues.length; i++) {
            if (arrtwovalues[i] != null) {
                counter++;
            }
        }

        for (int i = 0; i < arrtwovalues.length; i++) {
            if (arrtwovalues[i] != null) {
                list.add(arrtwovalues[i]);
            }
        }


        for (int i = 0; i < list.size(); i++) {
            if (list.size() > 0) {
                solve = list.get(0);
            }
        }


        System.out.println(solve);
            if (list.size() > 0) {
                return solve;
            }

            else return null;

    }


    public static void main(String[] args) {
      find(arr);

    }
}

这是我的测试：

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public final class FirstNonConsecutiveTest {
    @Test public void basicTests() {
        assertEquals(Integer.valueOf(6), FirstNonConsecutive.find(new int[]{1, 2, 3, 4, 6, 7, 8}));
        assertEquals(null, FirstNonConsecutive.find(new int[]{1, 2, 3, 4, 5, 6, 7, 8}));
        assertEquals(Integer.valueOf(6), FirstNonConsecutive.find(new int[]{4, 6, 7, 8, 9, 11}));
        assertEquals(Integer.valueOf(11), FirstNonConsecutive.find(new int[]{4, 5, 6, 7, 8, 9, 11}));
        assertEquals(null, FirstNonConsecutive.find(new int[]{31, 32}));
        assertEquals(Integer.valueOf(0), FirstNonConsecutive.find(new int[]{-3, -2, 0, 1}));
        assertEquals(Integer.valueOf(-1), FirstNonConsecutive.find(new int[]{-5, -4, -3, -1}));
    }
}

此测试未通过：

assertEquals(null, FirstNonConsecutive.find(new int[]{1, 2, 3, 4, 5, 6, 7, 8}));


java.lang.AssertionError: 
Expected :null
Actual   :6
 <Click to see difference>
Process finished with exit code -1

正如它所说：Expected :null和Actual :6

但是如果我用我的main方法尝试测试用例，那么它会正确返回6并且一切似乎都正常工作。

为什么我的测试没有通过？我错过了什么？

Answer 1

您的代码对于此任务而言非常复杂。尝试更简单的方法来避免错误，例如：

find(int[] arr) {
    if(arr.length > 0) {
        for(int i=1; i<arr.length; i++) {
            if(arr[i]-1 != arr[i-1]){
                System.out.println("The element " + arr[i] + " at the index " + i + " is the first not consecutive element of the array";
                return arr[i];
            }
        }
    }
    return null; //If we reach the end of the loop, there is no number not consecutive to a previous one.
}

目前您的问题是arrtwovalues和solve是静态的。因此，当您运行第一个测试时，您在其中输入一些值。当你运行第二次测试时，它们仍然包含这些值，因此它返回之前的值：6。

当您手动测试代码时，它会返回null，因为您之前没有进行过第一次测试，因此arrtwovalues和solve尚未包含值。

Answer 2

因此：

private static int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8};
private static List<Integer> list = new ArrayList<Integer>();
private static Integer[] arrtwovalues = new Integer[arr.length];

首先，变量arrtwovalues取决于arr.length的大小，它总是相同的。此外，这些值 不会在测试运行之间重置，因为所有测试代码都在同一方法中 。

将这些变量作为局部变量放在方法中，改为使用array.length：

static Integer find(final int[] array) {
    List<Integer> list = new ArrayList<Integer>();
    Integer[] arrtwovalues = new Integer[array.length];
    int[] temp = new int[array.length];

    ...

这将解决该测试用例，但您还有一个失败的测试用例：

assertEquals(Integer.valueOf(0), FirstNonConsecutive.find(new int[]{-3, -2, 0, 1}));

这似乎是由于您的代码处理0作为一种特殊情况而导致null在这种情况下。{/ p>

最好将每个测试用例放在@Test注释的自己的方法中，如下所示：

@Test
public void basicTests1() {
    assertEquals(Integer.valueOf(6), FirstNonConsecutive.find(new int[]{1, 2, 3, 4, 6, 7, 8}));
}

@Test
public void basicTests2() {
    assertEquals(null, FirstNonConsecutive.find(new int[]{1, 2, 3, 4, 5, 6, 7, 8}));
}

@Test
public void basicTests3() {
    assertEquals(Integer.valueOf(6), FirstNonConsecutive.find(new int[]{4, 6, 7, 8, 9, 11}));
}

@Test
public void basicTests4() {
    assertEquals(Integer.valueOf(11), FirstNonConsecutive.find(new int[]{4, 5, 6, 7, 8, 9, 11}));
}

@Test
public void basicTests5() {
    assertEquals(null, FirstNonConsecutive.find(new int[]{31, 32}));
}

@Test
public void basicTests6() {
    assertEquals(Integer.valueOf(0), FirstNonConsecutive.find(new int[]{-3, -2, 0, 1}));
}

@Test
public void basicTests7() {
    assertEquals(Integer.valueOf(-1), FirstNonConsecutive.find(new int[]{-5, -4, -3, -1}));
}

Answer 3

对于这个简单的问题，您的代码看起来很复杂。这可以完成这项工作

public Integer findFirstNonConsecutiveNumber(int[] arr){

    int element=-1;
    boolean found=false;
    ;
    for(int i=1;i < arr.length;i++){

        int prev=arr[i-1];
        if(arr[i]!=prev + 1)
        {
            element=arr[i];
            found=true;
            break;
        }

    }

    if(found)
        return element;
    else
        return null;
}

Answer 4

将所有字段替换为方法本身，并通过所有测试。

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

class FirstNonConsecutive {

    static Integer find(final int[] array) {
        List<Integer> list = new ArrayList<Integer>();
        Integer[] arrtwovalues = new Integer[array.length];
        Integer solve = null;
        int[] newtemp = new int[array.length];


        for (int i = 0; i < array.length - 1; i++) {
            newtemp[i] = array[i + 1];
        }

        for (int i = 0; i < array.length; i++) {
            if (newtemp[i] - array[i] == 2) {
                arrtwovalues[i] = newtemp[i];
            }
        }

        for (int i = 0; i < arrtwovalues.length; i++) {
            if (arrtwovalues[i] != null) {
                list.add(arrtwovalues[i]);
            }
        }

        for (int i = 0; i < list.size(); i++) {
            if (list.size() > 0) {
                solve = list.get(0);
            }else solve = null;
        }

        return solve;
    }

    public static void main(String[] args) {
        int[] arr = new int[]{4, 6, 7, 8, 9, 11};
        System.out.println(find(arr));

    }
}

Answer 5

尝试使用以下find（）方法：

public Integer find(final int[] array) {
    Integer val = null; // 1
    for (int i = 0; i < array.length - 1; i++) { // 2
        int current = array[i]; // 3
        int next = array[i + 1]; // 4
        if (current + 1 != next) { // 5
            val = next; // 6
            break; // 7
        }
    }
    return val; // 8
}

1 - 初始化整数变量＆＃34; val＆＃34;为null。

2 - i = 0表示循环将从输入＆＃34;数组＆＃34;的第一个元素开始。＆＃34; i＆lt; array.length - 1＆＃34;表示循环将一直持续到数组的倒数第二个元素，换句话说循环将排除最后一个元素。

3 - 数组的当前元素

4 - 数组的下一个元素

5 - 连续均值（当前+ 1 =下一个）。这个if条件是检查不连续的元素。

6 - 如果找到不连续的元素，则将其存储到＆＃34; val＆＃34;变量

7 - 由于找不到连续的元素，因此不需要检查其余的元素。

8 - 如果找到不连续的元素（6），则返回该元素，否则返回null（1）。

任务是找到不连续的数组的第一个元素

5 个答案: