計算數組中相同元素的唯一相鄰對的數量

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

我在代碼中看到一些問題。

在測試：

  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; 
       } 

你可以看到，第二個條件的第一部分始終是真實的，所以它等同於：

   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 2

一個可能的解決方案是：停止你仍然循環一次迭代早些時候：使用current < arr.length - 2（這將導致nextNext是陣列內總是）。在你的外部循環之後，只需比較數組的最後兩個元素。如果它們相等，則加1得到結果。完成。

除非數組的長度爲0或1，否則您需要特別對待。

Answer 3

我已經添加了一個額外的布爾值來跟蹤已經計數的重複之後。

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 4

一旦你發現了一雙跳過循環的索引。

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; 
    }