如何从int []数组（Java）中打印最长的数字序列

Question

我是编程的初学者，我需要从int []数组中打印最长的数字序列。 例如，如果我们有：

int[] numbers = {1, 3, 3, 5, 5, 5, 5, 5, 5, 6, 0, 12, 2, 2, 2, 12, 0}; 

的结果应该是：

String result = "5, 5, 5, 5, 5, 5"; 

我写了一些不好的代码，不工作，但也许它会给你一些想法。

public String findLargestSequence(int[] numbers) { 
     int bestStart = 0; 
     int curStart = 0; 
     int bestLength = 1; 
     int curLength = 1; 
     for (int i = 1; i < numbers.length; i++) { 
      if (numbers[i] > numbers[i - 1]) { 
       curLength++; 
       if (curLength > bestLength) { 
        bestStart = curStart; 
        bestLength = curLength; 
       } 
      } else { 
       curStart = i; 
       curLength = 1; 
      } 
     } 
     List<String> identical = new ArrayList<>(); 
     for (int i = 0; i < bestLength; i++) { 
      identical.add(String.valueOf(numbers[bestStart + i])); 
     } 
     return Joiner.on(", ").join(identical); 
    } 

更新。 感谢@phatfingers，我发现问题： (numbers[i] > numbers[i - 1])应该是(numbers[i] == numbers[i - 1])。 但还是有另一个问题。 如果我们有这样的事：

int[] numbers = {1, 2, 3, 3, 4, 4};

它的结果是：

"3, 3" 

我认为在这种情况下，我们可以：

1）说，我们不要” t具有任何一个最长的序列OR

2）显示所有序列，如：

String result = "Founded sequences: " + sequence1 + ", " + sequence2; 

3）对上面的代码不做任何事情。

你会怎么做？

Answer 1

本届展会最大的发生，还可以指望它，并打印出来

public static int consecutive(int[] array) { 
     if (array.length <= 1) { 
      return array.length; 
     }  
     int maxRun = 0; 
     for (int i = 1; i < array.length; i++) { 
      int thisRun = 1; 
      while (i < array.length && array[i - 1] + 1 == array[i]) { 
       thisRun++; 
       i++; 
      } 
      if (maxRun < thisRun) { // checking geater occurance 
       maxRun = thisRun; 
      } 
     } 
     return maxRun; 
    } 

Answer 2

你必须处理4例，算法可以分为两个部分划分：

设置状态目前意甲：

• 增量，如果它的增长目前意甲
• 重新初始化当前意甲时，它改变

设置最大意甲的状态：

• 增量，如果它生长
• 重新初始化最大意甲时，它改变

最大意甲

在实际的代码中，这些条件在循环中不受重视。

我评论两个逻辑错误来说明这个问题：

if (numbers[i] > numbers[i - 1]) { 
    // error : you don't increment the current serie when it grows 
    // because the condition if true only if the the current value is 
    // superior to the previous one 
    curLength++; 
    if (curLength > bestLength) { 
     bestStart = curStart; 
     bestLength = curLength; 
    } 
    } 
    // error : you don't reinit the current serie only when it changes 
    // because numbers[i] <= numbers[i - 1] is not true if the new number is 
    // superior to the previous one while it is a change 
    else {  
    curStart = i; 
    curLength = 1; 
    } 
} 

这里所提出的代码，处理4个条件两个两个：

public static String findLargestSequence(int[] numbers) { 

    // variables to maintain the max serie found and the number associated 
    int sizeMaxSerieFound = 0; 
    int numberMaxFound = numbers[0]; 

    // variables to maintain the current serie found and the number 
    // associated 
    int sizeMaxCurrentSerie = 0; 
    int numberCurrentSerie = numbers[0]; 

    boolean isMaxSerieIsTheCurrent = true; 

    for (int i = 0; i < numbers.length; i++) { 
     int currentNumber = numbers[i]; 

     // FIRST STEP : set the state of the current serie 

     // increment the current serie if it grows or for the first 
     // iteration 
     if (currentNumber == numberCurrentSerie) { 
      sizeMaxCurrentSerie++; 
     } 
     // else we reinit to 1 the current serie 
     else { 
      sizeMaxCurrentSerie = 1; 
      numberCurrentSerie = currentNumber; 
      isMaxSerieIsTheCurrent = false; 
     } 

     // SECOND STEP : set the state of the max serie 

     // we increment the current number of the actual max serie 
     if (currentNumber == numberMaxFound && isMaxSerieIsTheCurrent) { 
      sizeMaxSerieFound++; 
     } 

     // we reinit the serie because we have found a new greater serie 
     else if (currentNumber != numberMaxFound && sizeMaxCurrentSerie > sizeMaxSerieFound) { 
      sizeMaxSerieFound = sizeMaxCurrentSerie; 
      numberMaxFound = currentNumber; 
      isMaxSerieIsTheCurrent = true; 
     } 

    } 

    List<String> identical = new ArrayList<>(); 
    for (int i = 0; i < sizeMaxSerieFound; i++) { 
     identical.add(String.valueOf(numberMaxFound)); 
    } 
    return Joiner.on(", ").join(identical); 
}