数组项，并根据java中的规则递增计数器

我试图用java编写一个方法，在遍历数组时，每当满足以下规则之一时，该方法都会增加一个计数器

1数组中的两个相邻值彼此相等，每对中的第一个值从偶数索引值0,2,4…开始，以此类推

2对于所有相邻的条目对，一对条目的值等于下一对条目对和长度相邻条目对的值mod 2=0 所以0,0,0,0,1,1满足这个规则，但是0,0,0,1不满足，只有3个0违反了最后一个条件

到目前为止，我有这个，它实现了第一条规则：

public class ArrayEvaluate {

public static double evaluate(int[] array)
{
    double  ruleSat = 0;
      for(int index = 0; index < array.length; index++){

            if((array[index] == array[index + 1]) &&(index%2==0)){
                ruleSat++;
            }
}
return ruleSat;
}
 public static void main(final String[] args){

int[] array = new int[6];
array[0]= 1;
array[1]=1;
array[2]=3;
array[3]=3;
array[4]=4;
array[5]=4;

evaluate(array);
 }
}

然而，这并不完全有效，我也不知道第二条规则该怎么做

谢谢

这将防止接收到的索引越界错误

第二条规则的更新： 这分离了规则1和规则2的逻辑，因此如果需要单独更改规则，它们是独立的

公共类阵列评估{

public static double evaluate(int[] array) {
    double something = 0;
    int rule1Occurences = testRule1(array);
    int rule2Occurences = testRule2(array);
    System.out.println(rule1Occurences);
    System.out.println(rule2Occurences);
    return something;//not sure how rules relate
}
//This counts when array element == next array element
public static int testRule1(int[] array){
    int ruleSat = 0;
    for (int index = 0; index < array.length; index++) {
        if (index != array.length - 1) {
            if ((array[index] == array[index + 1]) && (index % 2 == 0)) {
                ruleSat++;
            }
        }
    }
    return ruleSat;     
}
//This blocks the pairs off in sets of two disregarding any odd parings
public static int testRule2(int[] array)
{
    int rule2Sat = 0;
    for (int index = 0; index < array.length; index++) {
        if(index <= array.length - 4){
            if (array[index] + array[index+1] == array[index+2] + array[index+3]) {
                rule2Sat++;
            }
        }
    }
    return rule2Sat;    
}

public static void main(final String[] args) {

    int[] dataSet = new int[6];
    dataSet[0] = 0;
    dataSet[1] = 0;
    dataSet[2] = 0;
    dataSet[3] = 0;
    dataSet[4] = 4;
    dataSet[5] = 4;

    System.out.println(evaluate(dataSet));
}

---

}既然你说这不是家庭作业，我就这么做

public class ArrayEvaluate {
    public static int evaluate(int... array) {
        int counter = 0;
        for(int i = 0; i < array.length-1; i += 2)
            if(array[i] == array[i + 1]) { // rule one
               counter++; 
               if (i < array.length-3 && 
                     array[i] == array[i + 2] && 
                     array[i + 2] == array[i + 3]) // rule two
                  counter++;
            }
        return counter;
    }


  public static void main(String... args){
    int test1 = evaluate(1,2,3,3,4,4);
    assert test1 == 2;
    int test2 = evaluate(0,0,0,0,1,1);
    assert test1 == 4;
    int test2 = evaluate(0,0,0,1,1,1);
    assert test1 == 2;
  }
}

---

我打赌他在上一次迭代中得到了一个超出范围的索引，因为：“ifarray[index]==array[index+1]”对于test1，断言test1应该等于2，因为只有3,3和4,4满足，在上一次测试中，它也应该是2，因为只有开头的0,0和结尾的1,1是满足的。因此，第二条规则应该匹配任何偶数大小大于2的条目，而不仅仅是4。如果偶数大小大于4，则只需检查前4条。如果你想让一对表示+1，两对表示+3 2对和1 4对，三对表示+6 3对，两4对和一批6 4对表示+10，等等，这只会有区别。

public class ArrayEvaluate {
    public static int evaluate(int... array) {
        int counter = 0;
        for(int i = 0; i < array.length-1; i += 2)
            if(array[i] == array[i + 1]) { // rule one
               counter++; 
               if (i < array.length-3 && 
                     array[i] == array[i + 2] && 
                     array[i + 2] == array[i + 3]) // rule two
                  counter++;
            }
        return counter;
    }


  public static void main(String... args){
    int test1 = evaluate(1,2,3,3,4,4);
    assert test1 == 2;
    int test2 = evaluate(0,0,0,0,1,1);
    assert test1 == 4;
    int test2 = evaluate(0,0,0,1,1,1);
    assert test1 == 2;
  }
}