Java 查找数组中重复数字之间的间距

我有一个带有数字列表的数组列表。每个数字始终在0到9之间。因此ArrayList包含如下数字：

1 2 7 4 9 1 8 3 2 9 0 1 3

我想在数字再次重复之前数一数间隔。例如，在再次重复之前，数字1的间隔为4。然后它又有一个6的间隙。我希望找出最多30个缺口。名单很长。我希望储存和生产以下产品：

Number 0 gap 1 : none
Number 0 gap 2: 5 times
Number 0 gap 3: 7 times
.....
Number 0 gap 30: none
Number 1 gap 1: 5 times
Number 1 gap 2: 3 times
......
Number 9 gap 30: 2 times

我真的不知道我该怎么做。我尝试了以下方法，但显然没有任何效果。寻找一些方向和帮助请

//arr is the ArrayList

int gapCount = 0;
int[] gaps = new int[10];

for (int i = 0; i < arr.size(); i++) {
     for (int j = 0; j < arr.size(); j++) {
        if(arr.get(i) == arr.get(j)){

        }
        gapCount++;
     }
}

//arr是ArrayList
int gapCount=0；
int[]间隙=新的int[10]；
对于（int i=0；i

您可以使用二维数组来保持间隙：

int[]gaps=newint[10][30]

您可以使用它来保持间隙的出现，如下所示：

int[][] gaps = new int[10][30];

for (int i = 0; i < (arr.size() - 1); i++) {

    int gapCount = 0;  // reset the gap count for the actual number

    for (int j = i + 1; j < arr.size(); j++) {

        if (arr.get(i) == arr.get(j)) {

            // we only track gaps greater than zero
            if(gapCount > 0) {  
                gaps[arr.get(i)][gapCount - 1]++; // increment the gap occurrence
            }

            break; // go to the next number in the list
        }

        gapCount++;

        // we don't want to track gaps greater than 30
        if(gapCount > 30) {
            break;
        }
    }
}

gaps[0][0]
保留
Number 0 gap 1的间隙

间隙[0][1]
保留
0号间隙2的间隙


gaps[1][0]
保留
1号gap 1的间隙

等等

代码如下所示：

int[][] gaps = new int[10][30];

for (int i = 0; i < (arr.size() - 1); i++) {

    int gapCount = 0;  // reset the gap count for the actual number

    for (int j = i + 1; j < arr.size(); j++) {

        if (arr.get(i) == arr.get(j)) {

            // we only track gaps greater than zero
            if(gapCount > 0) {  
                gaps[arr.get(i)][gapCount - 1]++; // increment the gap occurrence
            }

            break; // go to the next number in the list
        }

        gapCount++;

        // we don't want to track gaps greater than 30
        if(gapCount > 30) {
            break;
        }
    }
}

int[]gaps=newint[10][30]；
对于（int i=0；i<（arr.size（）-1）；i++）{
int gapCount=0；//重置实际数字的间隔计数
对于（int j=i+1；j0）{
间隙[arr.get（i）][gapCount-1]++；//增加间隙出现次数
}
break；//转到列表中的下一个数字
}
gapCount++；
//我们不希望跟踪大于30的差距
如果（间隙计数>30）{
打破
}
}
}
类似的东西可以工作，这是Java的基础：

    List<List<Integer>> gaps = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        gaps.add(new ArrayList<Integer>());
    }

    int lastPosition[] = new int[10];
    Arrays.fill(lastPosition, -1);

    for (int curIndex = 0; curIndex < arr.size(); curIndex++) {
        Integer curValue = arr.get(curIndex);
        if (lastPosition[curValue] != -1) {
            gaps.get(curValue).add(curIndex - lastPosition[curValue]);
        }
        lastPosition[curValue] = curIndex;
    }

    for (int i = 0; i < 10; i++) {
        if (gaps.get(i).isEmpty())
            System.out.print("Number " + i + ": none\n");
        else
            for (int index = 0; index < gaps.get(i).size(); index++)
                System.out.print("Number " + i + " gap " + index + " : " + gaps.get(i).get(index) + "\n");

    }

List gaps=new ArrayList（）；
对于（int i=0；i<10；i++）{
gaps.add（新的ArrayList（））；
}
int lastPosition[]=新int[10]；
数组。填充（最后位置，-1）；
对于（int curIndex=0；curIndex

当然，你应该调整它以适应你的30岁限制，但这很容易。
还有一个答案：

public class GapFinder {

  public HashMap<Integer, HashMap<Integer, Integer>> findGaps(List<Integer> input) {
    HashMap<Integer, Integer> lastSeen = new HashMap<Integer, Integer>();
    HashMap<Integer, HashMap<Integer, Integer>> result = new HashMap<Integer, HashMap<Integer, Integer>>();
    for (int position = 0; position < 10; position++) {
        result.put(position, new HashMap<Integer, Integer>());
    }
    for (int position = 0; position < input.size(); position++) {
        int number = input.get(position);
        if (lastSeen.get(number) != null) {
            int diff = position - lastSeen.get(number);
            if (result.get(number).get(diff) == null) {
                result.get(number).put(diff, 1);
            } else {
                int previous = result.get(number).get(diff);
                int incremented = previous + 1;
                result.get(number).put(diff, incremented);
            }
        }
        lastSeen.put(number, position);
    }
    return result;
  }
}

公共类间隙指示器{
公共HashMap findGaps（列表输入）{
HashMap lastSeen=新HashMap（）；
HashMap结果=新建HashMap（）；
对于（int位置=0；位置<10；位置++）{
put（位置，newhashmap（））；
}
对于（int position=0；position
这似乎具有二次时间复杂性，而您可以在线性时间内完成。我知道，这不是必需的……事实上，我并没有在2d阵列上做过很多工作，尽管你的想法似乎相当简单。目前我的arr尺寸是1000。Bu I get indexoutofbounds行间距错误[arr.get（I）][gapCount-1]+@这意味着
arr.get（i）
大于9或
gapCount
大于30。如果（gapCount>30）
，是否添加了检查？我最后用编辑插入了它。@user152468是不是因为
j=I+1
？不确定tho，可能是错的。它是O（n*（n-1）/2），与O（n^2）相同。不确定这是计算什么，但它似乎不是问题的答案。我用数组试过了。asList（1,1,2,3,2,1）得到了数字0:none数字1差距0:1数字1差距1:4数字2差距0:2数字3:none数字4:none数字5:none数字6:none数字7:none数字8:none数字9:none我想这是用户想要的，也许差距计算有1的差异，你可以替换“gaps.get”添加（curIndex-lastPosition[curValue]）；“with”间隙。获取（curValue）。添加（curIndex-lastPosition[curValue]-1）；“否。例如，“1号间隙1”应为0，因为两次出现的1之间没有大小为1的间隙。