Question

我的功能没有返回正确的答案。我的任务是计算一个数组中相同且相邻的两个数字，这里是一个样本：

array_1 = {1,2,2,3,4,4,2};   ans = 2
array_2 = {2,2,3,4,4};       ans = 2
array_3 = {1,1,1,1,1,1,1};   ans = 1
array_4 = {1,2,3,4,2};       ans = 0

这是我的功能。观察到的输出作为注释给出。

public class countClampsTest
{
    public static void main(String[] args)
    {
        int array_1[] = {1,2,2,3,4,4,2}; // expected result: 2
        int array_2[] = {2,2,3,4,4};     // expected result: 2
        int array_3[] = {1,1,1,1,1,1,1}; // expected result: 1
        int array_4[] = {1,2,3,4,2};     // expected result: 0

        System.out.println(countClamps(array_1)); // Returns 2
        System.out.println(countClamps(array_2)); // Returns 1
        System.out.println(countClamps(array_3)); // Returns 1
        System.out.println(countClamps(array_4)); // Returns 0
    }

    static int countClamps(int[] arr) {
        int result = 0;
        int nextNext = 0;
        for (int current = 0; current < arr.length - 1; current++) {
            for (int next = current; next <= current + 1; next++) {
                nextNext = next  + 1;
                if(nextNext >= arr.length) {
                    nextNext = arr.length -1;
                }
                if (arr[current] == arr[next] && current != next) {
                    if(arr[next] != arr[nextNext]) {
                        result++;   
                    } else if(arr[next] == arr[nextNext] && arr.length % 2 == 0) {
                        result = 1;
                    }
                }
            }
        }
        return result;
    }
}

Answer 1

一种可能的解决方案是：停止循环前一次迭代：使用current < arr.length - 2（这将导致nextNext始终在数组内）。在外部循环之后，只需比较数组的最后两个元素。如果它们相等，则将结果加1。完成。

除非数组的长度为0或1，否则您需要特别对待它。

Answer 2

我已经添加了一个额外的布尔值来跟踪已经计算过的重复项。

static int countClamps(int[] arr) {
    int result = 0;
    int prev = 0;
    boolean same = false;
    for(int i = 0; i < arr.length; i++) {
        if (i == 0) {
            prev = arr[i];
        } else {
            if (arr[i] == prev) {
                if (!same) {
                    result++;
                    same = true;
                }
            } else {
                prev = arr[i];
                same = false;
            }
        }
    }
    return result;
}

Answer 3

我在您的代码中看到了一些问题。

在测试中：

            if (arr[current] == arr[next] && current != next) {

你将当前与下一个比较;你可以通过在当前+ 1而不是当前开始下一个循环来获得相同的结果：

        for (int next = current+1; next <= current + 1; next++) {
            nextNext = next  + 1;
            ...
            if (arr[current] == arr[next]) {
               ...
            }
        }

使循环冗余：它只执行一次，所以上面的代码相当于：

            int next = current+1;
            nextNext = next  + 1;
            ...
            if (arr[current] == arr[next]) {
               ...
            }

现在进行内心测试：

                if(arr[next] != arr[nextNext]) {
                    result++;   
                } else if(arr[next] == arr[nextNext] && arr.length % 2 == 0) {
                    result = 1;
                }

您可以看到第二个条件的第一部分始终为true，因此它等同于：

                if(arr[next] != arr[nextNext]) {
                    result++;   
                } else if(arr.length % 2 == 0) {
                    result = 1;
                }

剩下的条件意味着如果数组具有偶数个元素，则将结果重置为1（为什么？）。

在数组的末尾，如果最后两个元素相等，结果将不会递增，这就是为什么在第二种情况下没有得到正确的结果。

这是我的解决方案：

static int countClamps(int[] arr) {
    int result = 0;
    for (int i = 1; i < arr.length; ++i) {
        if (arr[i] == arr[i-1]
                && (i == arr.length-1 || arr[i] != arr[i+1])) {
            ++result;
        }
    }
    return result;
}

Answer 4

Once you've found a pair skip an index in loop.

    public static int pairs(int[] list){
      int pairs = 0;
      for(int x = 1; x < list.length; x++){
        if(list[x] == list[x-1]){
          pairs++;
          x=x+1;}
      }
      return pairs;
    }

计算数组中相同元素的唯一相邻对的数量

4 个答案: