Java 确定列表编号是否连续

我在Java工作。我有一个无序的5个数字列表，从0到100不等，没有重复。我想检测是否有3个数字是连续的，没有间隔

示例：

[9,12,13,11,10] true
[17,1,2,3,5] true
[19,22,23,27,55] false

至于我试过什么，还没有。如果我现在就写，我可能会使用最简单的方法对数字排序，然后迭代检查序列是否存在。

非常简单（但更快）的算法：（您的数组是input[]，假设它只包含您所说的0-100个数字）

int[]nums=newint[101]；
对于（i=0；i0）{nums[a-1]++；}
如果（a分配一个大小为100的数组：

private static final int MAX_VALUE = 100;

public boolean hasSequence(int [] values) {
  int [] bigArray = new int[MAX_VALUE];

  for(int i = 0; i < values.length; i++) {
    bigArray[values[i]] = 1;
  }

  for(int i = 0; i < values.length; i++) {
    index = values[i];
    if(index == 0 || index == MAX_VALUE-1) {
      continue;
    }
    if(bigArray[index-1] == 1 && bigArray[index+1] == 1) {
      return true;
    }
  }

  return false;
}

private static final int MAX_VALUE=100；
公共布尔hasSequence（int[]值）{
int[]bigArray=新的int[MAX_值]；
对于（int i=0；i
此代码似乎正在实现您的需求：

public class OrderdedList {
    public static void main(String[] args) {
        System.out.println(orderedWithNoGap(Arrays.asList(9, 12, 13, 11, 10))); // true
        System.out.println(orderedWithNoGap(Arrays.asList(17,1,2,3,5))); // true
        System.out.println(orderedWithNoGap(Arrays.asList(19,22,23,27,55))); // false
    }

    private static boolean orderedWithNoGap(List<Integer> list) {       
        Collections.sort(list);
        Integer prev = null;
        int seq = 0;
        for(Integer i : list) {
            if(prev != null && prev+1 == i)
                seq = seq == 0 ? 2 : seq+1;
            prev = i;
        }
        return seq >= 3;
    }

}

公共类OrderdedList{
公共静态void main（字符串[]args）{
System.out.println（orderedWithNoMap（Arrays.asList（9,12,13,11,10））；//true
System.out.println（orderedWithNoMap（Arrays.asList（17,1,2,3,5））；//true
System.out.println（OrderedWithNoMap（Arrays.asList（19,22,23,27,55））；//false
}
私有静态布尔OrderedWithNoMap（列表）{
集合。排序（列表）；
整数prev=null；
int-seq=0；
for（整数i：列表）{
if（prev！=null&&prev+1==i）
seq=seq==0？2:seq+1；
prev=i；
}
返回序列>=3；
}
}
通用算法步骤。

Step 1. Sort the array.
Step 2. There are only 3 possible groups of 3 (next to each other) in an array of length five.
indexes 0,1,2 - 1,2,3 - 2,3,4.
Step 3. Check these 3 combinations to see if the next index is 1 more than the current index.

正如OP在中指出的，他想检查列表是否包含3个或更多的序列号

public class WarRoom {

    static final int seqCount = 3;

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>((Arrays.asList(9, 11, 123, 511, 10)));
        for (int i : list) {
            if (seqNumbers(list, i, 0) >= seqCount) {
                System.out.println("Lucky Numbers : " + (i++) + "," + (i++) + "," + i);
            }
        }
    }

    public static int seqNumbers(List<Integer> list, int number, int count) {
        if (list.contains(number)) {
            return seqNumbers(list, number + 1, count + 1);
        }
        else {
            return count;
        }
    }
}

公共级作战室{
静态最终int seqCount=3；
公共静态void main（字符串[]args）{
List List=newarraylist（（Arrays.asList（9,11,123,511,10））；
用于（int i:列表）{
if（seqNumbers（list，i，0）>=seqCount）{
System.out.println（“幸运数字：”+（i++）+，“+（i++）+”，“+i”）；
}
}
}
公共静态整数序列号（列表、整数编号、整数计数）{
if（列表包含（编号））{
返回序号（列表，序号+1，计数+1）；
}
否则{
返回计数；
}
}
}

这不是最有效的解决方案之一，但我喜欢递归！
还没有测试过这一点，但对于较小的内存占用，您可以使用位集

private static boolean consecutive(int[] input) {
    BitSet bitSet = new BitSet(100);
    for (int num : input) {
        bitSet.set(num);
    }

    bitSet.and(bitSet.get(1, bitSet.length())); // AND shift left by 1 bit
    bitSet.and(bitSet.get(1, bitSet.length())); // AND shift left by 1 bit

    return !bitSet.isEmpty();
}

我不明白-第一个序列是怎样的
真的
？我想问题是，是否有3个数字可以排列成无间隔的序列。@佩斯：啊，是的，一定是这样。看起来不像apache。commons:D建议：只需实现您提到的算法。排序并通过，如果检测到3个Inkrmental，则设置一个标志三个或更多。这就是第一个序列
为真的原因。您运行了吗？
Arrays.asList（）
返回一个不可变的
List
@LukasEder是的，我执行了。
公共静态列表asList（T…a）{返回新的ArrayList（a）；}
@LukasEder它返回一个固定大小的
列表，该列表不是
java.util.ArrayList
。您不能
向它添加（）
，也不能
从中删除（）
，但可以调用
set（）
，所以就地突变是可以的。那不是
java.util.ArrayList
，而是
java.util.Arrays.ArrayList
。但我错了，它不是一成不变的。它只是一个固定大小的列表。哇，今天学到了一些东西！（经过这么多年…）需要OP似乎不想要的排序。要求您循环遍历100个大小的数组。如果有人想知道为什么这不是选定的答案，我测试并选择了最快的答案。不过我很欣赏这个答案。不，这是可读的伪代码，恰巧看起来像我能想到的另一种语言。这也是唯一的一种到目前为止的方法是O（列表中的项目）即使存在重复项，也可以工作。我继续使用Java表单替换它，并删除了小数组。此解决方案将在第二个循环中引发索引越界异常。此外，第二个循环不应该通过值中的整数，而不是0和其大小之间的整数进行循环吗？我认为第7行应该读取
if（bigArray[values[i]-1]==1&&bigArray[values[i]+1]==1）
但在此之前，应该检查以确保值[i]！=0。如果编辑此答案以解决此问题，它将是可接受的答案，因为我认为它是最快的，同时也非常清晰。@roundar谢谢，已清理完毕。没有实际需要检查该值[index]！=0。OP已经说过他有一个使用排序的解决方案，但正在寻找一个不使用排序的解决方案。这个答案使用带位移位的位集来查找集合中的连续位
    int[] arr = {9,12,13,11,10};
    BitSet numbers = new BitSet(101);
    for (int no : arr) {
        numbers.set(no);
    }
    int sequenceCount = 0;
    int last = -10;
    for (int i = numbers.nextSetBit(0); i >= 0; i = numbers.nextSetBit(i+1)) {
        if (sequenceCount == 0 || i - last > 1) {
            sequenceCount = 1;
        } else {
            sequenceCount++;
            if (sequenceCount >= 3) {
                System.out.println("Sequence start: " + (last - 1));
                break;
            }
        }
        last = i;
    }
    System.out.println("Done");

public class WarRoom {

    static final int seqCount = 3;

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>((Arrays.asList(9, 11, 123, 511, 10)));
        for (int i : list) {
            if (seqNumbers(list, i, 0) >= seqCount) {
                System.out.println("Lucky Numbers : " + (i++) + "," + (i++) + "," + i);
            }
        }
    }

    public static int seqNumbers(List<Integer> list, int number, int count) {
        if (list.contains(number)) {
            return seqNumbers(list, number + 1, count + 1);
        }
        else {
            return count;
        }
    }
}

private static boolean consecutive(int[] input) {
    BitSet bitSet = new BitSet(100);
    for (int num : input) {
        bitSet.set(num);
    }

    bitSet.and(bitSet.get(1, bitSet.length())); // AND shift left by 1 bit
    bitSet.and(bitSet.get(1, bitSet.length())); // AND shift left by 1 bit

    return !bitSet.isEmpty();
}