1

我有一个问题要问：

编写一个程序，将其输入参数转换为一个整数数组，然后找到最长的等值连续序列的长度和位置，其中该序列之前和之后的元素的值较小。例如，如果命令行参数是“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”的输入，我不断得到一个数组索引越界错误。

4

3 回答 3

3

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

例如

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

将这些说明写给作为人类的自己，并尝试遵循它们，并在发现极端情况时对其进行修复。一旦你有了一个有效的人类语言算法，编写代码几乎是自我驱动的。

于 2013-11-05T02:27:41.917 回答
2

您确实需要发布您所看到的具体问题、实际结果与预期结果有何不同以及您尝试了哪些解决方案。

无论如何，对于一般的“如何进行”问题，我发现首先在纸上解决这些类型的问题通常会有所帮助。写下您的序列并逐步完成，观察您需要跟踪哪些信息以及需要应用哪些逻辑来产生所需的结果。一旦您能够做到这一点，将您经过深思熟虑的算法转换为具体代码将更加直接。

看来您至少在​​某种程度上在正确的轨道上解析和存储您的整数数组，但是您的[t+?]前瞻有点误导。如果你把它写出来并用手逐步完成，你可能会对你想出的东西感到惊讶。

于 2013-11-05T02:22:25.570 回答
0

这是带有测试用例的完整程序描述：

给定一个整数数组 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);
}
}
于 2021-01-31T08:34:14.140 回答