Question

我有一个问题：

编写一个程序，将其输入参数转换为数组整数，然后找到最长的长度和位置连续的相等值序列，其中元素的值就在这个序列之前和之后就更小了。例如，如果命令行参数是“1 2 2 2 2 5 5 5 3”您的程序应该输出数字5 3（第一个数字是从零开始的偏移量，和第二个数字是子序列的长度。如果是连续的子序列出现在数组的开头或结尾，请对此进行处理作为特殊情况;例如，对于输入“5 5 5 5 3 8 8 8 1”，您的输出应该是是0 4（而不是5 3）。如果有多个子序列满足上面的条件，然后输出第一个。

更新的代码：

public class LongestPlateau {
public static void main(String[] args) {
    // TODO - Your solution
     int N= args.length;
    int [] array = new int [N]; 
    int new_length=0;
    int location=0;
    int max=0;
    int current_length=0;

     //assign digits into array
   for (int i=0; i < N; i++){
    int number = Integer.parseInt(args[i]);
    array [i] = number;
    }



int compare=array[0];
  for (int l=0; l<N; l++){

if (array[l] < compare){
    current_length=0;
    compare = array[l];
}
else if (array[l] == compare){
    current_length+=1;
    compare = array[l];
}

else if (array[l] > compare){
    compare=array[l];
    l++;
}

compare= array[l];

        for (int b=0; b<N; b++){
            if (current_length > max){
                max = current_length;
                location = array[l];
                new_length=max-1;
                } 
            else if (current_length==1){
                new_length=max;
            }
        }

            }
 System.out.println(location);
   System.out.println(new_length);
   }

 }

问题是，对于输入“1 2 3 4”，我不断得到一个数组索引越界错误。

Answer 1

在开始编写代码之前，请尝试思考一个人如何解决它。

e.g。

对于输入中的每个项目，将其与之前的项目进行比较，如果它更大，则开始新的序列长度检查（在笔记本中写入0 - “当前序列长度”），如果它相同，则将其增加1 ，如果它更少，则将序列长度标记为完成。如果它大于目前为止的最大序列长度（从0开始），那么现在这是您的最大序列，如果不是，则忽略该序列长度并继续前进到下一个字符。（或类似的东西）

将这些说明作为人类写给自己，并尝试遵循它们，并在找到边缘情况时修复它们。一旦你有一个可行的人类语言算法，编写代码几乎是自我驱动的。

Answer 2

您确实需要发布您所看到的具体问题，实际结果与预期结果的差异以及您尝试过的解决方案。

在任何情况下，对于一般的“如何处理”问题，我发现通常有助于在纸上解决这些类型的问题。记下你的序列并逐步完成它，观察你需要跟踪的信息以及你需要应用什么逻辑来产生所需的结果。一旦你能够做到这一点，将清晰思考的算法转化为具体的代码将会更加直接。

看起来你至少在某种程度上正确地解析和存储你的整数数组，但你有点误导你的[t+?]前瞻。如果你把它写出来并手工操作，你可能会对你的想法感到惊讶。

Answer 3

以下是包含测试用例的完整程序说明：

给定一个整数数组 int A[]，找出最长的等值连续序列的长度和位置，其中该序列前后元素的值较小。

你应该只打印这两个数字（第一个是长度，第二个是高原的起始索引）。

为了完成定义，我们可以考虑在 A[-1] 和 A[A.length] 处存在虚索引位置，其中 A[-1] < A[0] 和 A[A.length] < A[ A.length-1]。因此，高原可以在阵列A的两端开始/结束。这个条件保证了高原的存在。高原的长度可以是 1。

示例 1：

java LongestPlateau 1 2 2 2 2 1

使用这个命令行参数，程序应该打印：

4
1

示例 2：

java LongestPlateau 1 2 2 2 2 3

使用这个命令行参数，程序应该打印：

1
5

示例 2：

java LongestPlateau 3 2 2 2 1 2 1 1 1 2 2 0 1 1 1 1 0

使用这个命令行参数，程序应该打印：

4
12

示例 2：

java LongestPlateau 3 2 2 2 2 2 2 1 2 1 1 1 2 2 0 1 1 1 1

使用这些命令行参数，程序应该打印：

4
15

这是我的解决方案：

public class LongestPlateau {
private static int[] parseInputArray(String[] args) {
    int[] value = new int[args.length+1];
    for(int i = 0 ; i < args.length; i++){
        if (i == args.length-1) value[i] = 0; // this imaginary last value of the array ensures that if the plateau is the last value of the array, then it outputs the correct answer
        value[i] = Integer.parseInt(args[i]);
    }
    return value;
}
public static void printLargestPlateau(int[] values) {
    int biggestStartIndex = -1;
    int biggestLength = 0;
    int currentIndex = 1;
    int currentPlateauStartIndex = 1;
    int currentLength = 1;
    boolean plateauStarted = false;
    while (currentIndex < values.length) {
        if(isStartOfPlateau(currentIndex, values)){
            currentLength = 1;
            plateauStarted = true;
            currentPlateauStartIndex = currentIndex;
        } else if (isEndOfPlateau(currentIndex, values)) {
            if(plateauStarted && currentLength > biggestLength){
                biggestLength = currentLength;
                biggestStartIndex = currentPlateauStartIndex;
            }
            plateauStarted = false;
            currentLength = 1;
        } else {
            currentLength++;
        }
        currentIndex++;
    }
    System.out.println(biggestLength +"\n"+biggestStartIndex);
}

private static boolean isStartOfPlateau(int index, int[] values){
    if(index <= 0){
        return false;
    }
    return values[index-1] < values[index];
}

private static boolean isEndOfPlateau(int index, int[] values){
    if(index <= 0){
        return false;
    }
    return values[index - 1] > values[index];
}
public static void main(String[] args) {
    int[] values = parseInputArray(args);
    printLargestPlateau(values);
}
}

最长的连续序列的相等值的长度和位置，其中恰好在之前和之后较小

3 个答案: