数组中连续的偶数和连续的奇数

Question

我有一个代码，将连续的even数字和连续的odd数字相加，然后将它们添加到arraylist。应重复此过程，直到列表中不再有连续的奇数或偶数。然后返回arraylist的大小。

我使用嵌套for循环，问题是循环检查相同index这是没有意义的。

这里是我的代码：

public static int SumGroups(int[] arr) { 
    ArrayList<Integer> arl = new ArrayList<Integer>(); 
    int even = 0, odd = 0; 
    for (int i = 0; i < arr.length; i++) { 
     for (int j = i + 1; j < arr.length; j++) { 
      if (arr[i] % 2 == 0) { 
       even += arr[i]; 
       if (arr[j] % 2 == 0) { 
        even += arr[j]; 
       } else { 
        arl.add(even); 
        even = 0; 
        break; 
       } 
      } else { 
       odd += arr[i]; 
       if (arr[j] % 2 != 0) { 
        odd += arr[j]; 
       } else { 
        arl.add(odd); 
        odd = 0; 
        break; 
       } 
      } 
     } 
    } 
    return arl.size(); 
} 

我的问题是： 如何防止环路从检查相同指数？ 换句话说，如何让我的代码总和连续的偶数和连续的奇数？

输入：

int arr[]={2, 1, 2, 2, 6, 5, 0, 2, 0, 5, 5, 7, 7, 4, 3, 3, 9}; 

输出：

6 // [2, 1, 10, 5, 30, 15] 

Answer 1

I think the following code should solve the problem, if you do not want to output the size simply return `sums` instead of `sums.size()` 

public static int sumGroupsRecursively(int[] arr) { 
     List<Integer> numbersToSum = IntStream.of(arr).boxed().collect(Collectors.toList()); 
     List<Integer> currentSumList = sumSublist(numbersToSum); 
     List<Integer> nextSumList = sumSublist(currentSumList); 

     while (currentSumList.size() != nextSumList.size()) { 
      currentSumList = nextSumList; 
      nextSumList = sumSublist(currentSumList); 
     } 

     return nextSumList.size(); 
    } 


    public static List<Integer> sumSublist(List<Integer> list) { 
     int current = list.get(0); 
     int currentSum = 0; 
     List<Integer> sums = new ArrayList<>(); 
     for (int i = 0; i < list.size(); i++) { 
      if (current % 2 == list.get(i) % 2) { 
       currentSum += list.get(i); 
      } else { 
       sums.add(currentSum); 
       current = list.get(i); 
       currentSum = current; 
      } 
     } 
     sums.add(currentSum); 
     return sums; 
    } 

如果你需要做的这一个功能我会阻止，因为这是很难读你可以使用这样的代码。

public static Integer sumSublist(int[] arr) { 
    List<Integer> sums = new ArrayList<>(); 
    sums.add(0); 
    int i = 0; 
    while (i < arr.length - 1) { 
     int current = arr[i]; 
     int currentSum = 0; 
     while (current % 2 == arr[i] % 2) { 
      currentSum += arr[i]; 
      if (i >= arr.length - 1) { 
       break; 
      } 
      i++; 
     } 
     if (currentSum % 2 == sums.get(sums.size()-1) % 2) { 
      sums.set(sums.size() - 1, sums.get(sums.size()-1) + currentSum); 
     } else { 
      sums.add(currentSum); 
     } 
    } 
    return sums.size(); 
} 

Answer 2

您正在输入您的第一个for循环传入arr。在第一个for循环中，第二次输入第二个for循环传递给arr。这意味着您每次输入第二个for循环的次数与arr中的元素和第二个for循环中的横向arr次数相同。例如，如果arr.length（）是2，那么您会横向放置3次arr.length（）。一旦进入外循环，并在内循环中进行两次（对于arr中的每个元素一次）。第二，通过在您的数组列表中添加奇数和偶数，您除了重构arr之外无所作为，而是以数组而不是数组。因此，返回arl.size（）与返回已知的arr.length（）完全相同，而且更容易完成。

尽管如此，这里是我将如何计算奇数和平均值的总和。我将这两个添加到不同的数组列表中。您需要明确您需要返回的内容，因为您的描述已关闭。

public void test(){ 

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

int testOfEven = 6; 
int testOfOdd = 9; 
int sumOfEven = 0; 
int sumOfOdd = 0; 

ArrayList evens = new ArrayList<Integer>(); 
ArrayList odds = new ArrayList<Integer>(); 

for(int i = 0; i < arr.length; i++) 
{ 
    if ((arr[i]%2) == 0) 
    { 
    evens.add(arr[i]); 
    sumOfEven += arr[i]; 
    } 
    else 
    { 
    odds.add(arr[i]); 
    sumOfOdd += arr[i]; 
    } 
} 

assertEquals(testOfEven, sumOfEven); 
assertEquals(testOfOdd, sumOfOdd); 

}

Answer 3

玩了一段时间后，这里是我的版本：

public static int SumGroups(final int[] arr) { 
    if (arr.length > 0) { 
     int n, sum, psum; 
     psum = sum = n = arr[0] & 1; // parity of first number in sequence 
     int s = 1; // at least one element in array 
     int f = 0; // discard first parity change 
     for (int i = 1; i < arr.length; i++) { 
      if (n == (arr[i] & 1)) { 
       sum = (sum + n) & 1; // both even or odd, just increase sum 
      } else { 
       s += (psum^sum) & f; // compare sums parity 
       psum = sum; // store current sum's parity 
       sum = n = arr[i] & 1; // new first number in sequence 
       f = 1; // do not discard sums parity next time 
      } 
     } 
     s += (psum^sum) & f; // array ended, check parity of last sum 
     return s; 
    } 
    return 0; 
} 

我已经把意见，但还是有些其他注意事项：

1. 基本思路是与@PKuhn相同，只是检查了一些边缘情况（空数组，整数溢出）
2. 我们并不需要有资金的阵列，我们只需要以前的总和，并检查它的平价新计算
3. sum = (sum + n) & 1 - 我们并不需要计算整个总之，我们只需要和的奇偶性
4. s += (psum^sum) & f - 我们需要增加交换柜台只有平价发生变化，XOR帮助我们拿到1，如果更改，否则为0

这里是我使用的测试列表：

Assert.assertEquals(6, SumGroups(new int[] { 2, 1, 2, 2, 6, 5, 0, 2, 0, 5, 5, 7, 7, 4, 3, 3, 9 })); 
    Assert.assertEquals(6, SumGroups(new int[] { 0, 0, 0, 0, 2, 1, 2, 2, 6, 5, 0, 2, 0, 5, 5, 7, 7, 4, 3, 3, 9 })); 
    Assert.assertEquals(1, SumGroups(new int[] { 2, 3, 3 })); 
    Assert.assertEquals(1, SumGroups(new int[] { 2 })); 
    Assert.assertEquals(1, SumGroups(new int[] { 2, 2 })); 
    Assert.assertEquals(1, SumGroups(new int[] { 2, 3, 3, 3, 3, 2 })); 
    Assert.assertEquals(2, SumGroups(new int[] { 3, 2, 2 })); 
    Assert.assertEquals(2, SumGroups(new int[] { 1, 3, 3, 2, 2 })); 
    Assert.assertEquals(2, SumGroups(new int[] { 1, 2, 3, 3, 2, 3, 3, 2 })); 
    Assert.assertEquals(1, SumGroups(new int[] { 3, 3, 2, 2 })); 
    Assert.assertEquals(1, SumGroups(new int[] { Integer.MAX_VALUE, Integer.MAX_VALUE })); 
    Assert.assertEquals(1, SumGroups(new int[] { Integer.MAX_VALUE, Integer.MAX_VALUE, 2 })); 
    Assert.assertEquals(1, SumGroups(new int[] { Integer.MAX_VALUE, Integer.MAX_VALUE, 3 })); 

Answer 4

public void findEvenOdd（int a []）{

Boolean flip = false; 
    int sum = 0, i, m = 0; 
    for (i = 0; i < a.length; i++) { 
    if (flip) { 
    System.out.print(sum + "\t"); 
    sum = a[i]; 
    flip = !flip; 
    if (i + 1 < a.length && (a[i] % 2 != a[i + 1] % 2)) 
    flip = !flip; 
    m++; 
    } else { 
    sum += a[i]; 
    if (i + 1 < a.length && (a[i] % 2 != a[i + 1] % 2)) 
    flip = !flip; 
    m++; 
    } 

    } 

    if(m!=a.length-1) 
    System.out.print(a[a.length-1] + "\t"); 
    }