Question

我正在解决一个问题，因为我必须连续返回大于或等于列表中给定元素的最大次数。例如：- 考虑一个元素列表[5,10,8,9] and element = 8，这里有3个连续元素，它们大于（等于）8个，即10,8,9，所以我返回3。

另一个例子：-

考虑元素列表[5,10,8,9,1,2,3,4,5,8,9] and element =8这里有3个大于（或等于）8个连续元素，即10,8,9，但之后有5个小于8个连续元素，即{{ 1}}，因此最多为5，因此我返回5。

我尝试了以下代码，但没有得到正确的答案。

我所做的是遍历列表，查看元素是否大于给定元素（如果是递增的话），直到接收到较小的元素为止，如果接收到的元素较小，则将计数器加到设置并使其为零。对于较低的元素也是如此。最后，我尝试返回最大的元素。但是我不知道它是如何工作的，我添加的所有元素都没有添加到集合中。

1,2,3,4,5

Answer 1

问题是您在HashSet中添加了错误的值。增加longWork时，您需要添加longWork而不是shortWork，如下所示：

public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(new Integer[] {5, 10, 8, 9, 1, 2, 3, 4, 5, 8, 9});
    List<Integer> list2 = Arrays.asList(new Integer[] {5, 10, 8, 9});
    List<Integer> list3 = Arrays.asList(new Integer[] {5, 10, 6, 8, 4, 9});
    System.out.println(list1 + " -> " + findLongest(list1, 8));
    System.out.println(list2 + " -> " + findLongest(list2, 8));
    System.out.println(list3 + " -> " + findLongest(list3, 8));
}

public static int findLongest(List<Integer> hours, int limit) {
    int longWork = 0;
    int shortWork = 0;

    Set<Integer> hash_set = new HashSet<Integer>();
    for (int i = 0; i < hours.size(); i++) {
        if (hours.get(i) >= limit) {
            longWork++;
            hash_set.add(longWork);
            shortWork = 0;
        }
        else if (hours.get(i) < limit) {
            shortWork++;
            hash_set.add(shortWork);
            longWork = 0;
        }
    }
    int finalAns = Collections.max(hash_set);
    return finalAns;
}

然后输出为：

[5, 10, 8, 9, 1, 2, 3, 4, 5, 8, 9] -> 5
[5, 10, 8, 9] -> 3
[5, 10, 6, 8, 4, 9] -> 1

编辑：或者（如注释中所述），您可以仅在循环后添加最终值，以确保添加了最后一个值，尽管不再有其他数字了（例如第二个列表：longWork的值为3，但从不添加，因为在列出较大的值之后没有较小的值。

这也将起作用：

public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(new Integer[] {5, 10, 8, 9, 1, 2, 3, 4, 5, 8, 9});
    List<Integer> list2 = Arrays.asList(new Integer[] {5, 10, 8, 9});
    List<Integer> list3 = Arrays.asList(new Integer[] {5, 10, 6, 8, 4, 9});
    System.out.println(list1 + " -> " + findLongest(list1, 8));
    System.out.println(list2 + " -> " + findLongest(list2, 8));
    System.out.println(list3 + " -> " + findLongest(list3, 8));
}

public static int findLongest(List<Integer> hours, int limit) {
    int longWork = 0;
    int shortWork = 0;

    Set<Integer> hash_set = new HashSet<Integer>();
    for (int i = 0; i < hours.size(); i++) {
        if (hours.get(i) >= limit) {
            longWork++;
            hash_set.add(shortWork);
            shortWork = 0;
        }
        else if (hours.get(i) < limit) {
            shortWork++;
            hash_set.add(longWork);
            longWork = 0;
        }
    }
    //add the last values
    hash_set.add(shortWork);
    hash_set.add(longWork);

    int finalAns = Collections.max(hash_set);
    return finalAns;
}

输出再次是：

[5, 10, 8, 9, 1, 2, 3, 4, 5, 8, 9] -> 5
[5, 10, 8, 9] -> 3
[5, 10, 6, 8, 4, 9] -> 1

Answer 2

此实现的问题在于，您不处理上一次运行：在循环后不添加longWork和shortWork的最终值。（这也意味着您将获得一个空输入的异常）。

在调用Collections.max之前，请尝试在循环后将它们都添加到集合中。

但是，这里不需要设置。您只是在寻找最长的运行时间，因此您所要做的就是保持最长的运行时间。

int longest = 0;
int a = 0;
while (a < hours.length()) {
  // Start of this run.
  int start = a;
  // Value of discriminator in this run.
  boolean ge = hours.get(a) >= limit;

  // Increment the pointer until you hit the end,
  // or you find the first element of the next run.
  do {
    ++a;
  } while (a < hours.length()
     && (hours.get(a) >= limit) == ge);

  // Maybe update the longest.
  longest = max(longest, a - start);
}
return longest;

Answer 3

首先，您的解决方案存在缺陷。单个哈希集不是记住“记住”所需信息的正确数据结构。而且，在每次循环操作期间不断将值推入该集合实际上并没有帮助（请注意，您的代码执行if / else ...，而if-then和if-else都将值推入该集合：没有任何用处。）

要真正解决问题，请记住您必须做的事情：必须标识列表中的连续子列表，其子列表中的数字为 = X。

要解决您的问题，您必须遍历列表，然后需要记住以前发生的事情：

如果您位于“子序列”中，则必须确定列表中的下一个元素是否也属于该序列，如果是，则当前子序列又获得一个元素
如果“子序列”刚刚结束，则应检查该子序列是否具有比以前的子序列更多的元素

Answer 4

此问题可以简化为已知的标准问题，即二进制数组中的最大连续一个（或零）。大于或等于限制的元素可以表示为1，小于或等于限制的元素可以表示为0。因此对于以下示例：

[5,10,8,9]和element = 8

问题减少到

在二进制数组[0,1,1,1]中查找最大连续的一个（或零）。

Answer 5

这还将检查较小或较大的数字是否连续。也许不是最有效的，但是它可以工作。

public static int findLongest(List<Integer> hours, int limit) {
    int longWork = 0;
    int shortWork = 0;
    Set<Integer> hash_set = new HashSet<>();

    Collections.sort(hours);
    int value;

    for(int i = 0; i< hours.size(); i++){
        value = hours.get(i);
        if(hours.size()- 1 == i){
            if((hours.get(hours.size() - 1) == hours.get(i - 1) + 1) && hours.get(i) >= limit){
                longWork++;
                hash_set.add(longWork);
                break;
            }
            break;

        }else{
            if((value + 1) == hours.get(i + 1) && hours.get(i) >= limit){
                longWork++;
            }else {
                longWork++;
                hash_set.add(longWork);
                longWork = 0;
            }
        }

    }

    for(int i = 0; i< hours.size(); i++){

        value = hours.get(i);

        if(hours.size()- 1 == i){
            if((hours.get(hours.size()- 1) == hours.get(i - 1) + 1) && hours.get(i) <= limit){
                shortWork++;
                hash_set.add(shortWork);
                break;
            }
            break;

        }else{
            if((value + 1) == hours.get(i + 1) && hours.get(i) <= limit){
                shortWork++;
            }else {
                shortWork++;
                hash_set.add(shortWork);
                shortWork = 0;
            }
        }
    }

    int finalAns = Collections.max(hash_set);
    return finalAns;

}

我想要最大数量大于或等于给定元素的连续元素

5 个答案: