List Kotlin中列表中的连续整数组

我有一个按顺序排列的整数列表。我想要的是从列表中获得连续整数组

例如：

输入：[19,20,21,22,23,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,59,60,61,62,63,64,65,66,73,74,75,76,77]

期望输出：[[19,20,21,22,23]，[30,31,32,33,34,35,36,37,38,39,40,41,42,43,44]，[59,60,61,62,63,64,65,66]，[73,74,75,76,77]]

这是我的密码：

    private fun getConsecutiveNumbers(srcList: ArrayList<Int>): List<List<Int>> {

        val listConsecNums = ArrayList<List<Int>>()
        var subList = ArrayList<Int>()

        for (i in 0 until srcList.size) {
            subList.add(srcList[i])

            if ((i + 1 >= srcList.size) || (srcList[i] + 1 != srcList[i + 1])) {
                listConsecNums.add(subList)
                subList = ArrayList()
            }
        }

        return listConsecNums

    }

private fun getconsutivenumbers（srcList:ArrayList）：List{
val listconsernums=ArrayList（）
var subList=ArrayList（）
for（0中的i，直到srcList.size）{
subList.add（srcList[i]）
if（（i+1>=srcList.size）| |（srcList[i]+1！=srcList[i+1]））{
添加（子列表）
subList=ArrayList（）
}
}
返回列表
}

在这里，代码假定这些数字是连续的，并将它们收集到一个列表中，直到找到一个非连续的数字

这段代码适用于我想要的一般情况，但我只是想知道是否有一种更有效的Kolin-y方法可以做到这一点

---

任何建议都将不胜感激。

这里有一种不同的方法，它更紧凑，但效率较低，因为它会创建两个中间的一次性列表

首先，获取与每个连续运行的开始相匹配的索引列表。然后压缩范围开始和结束，以拉出原始列表的相关范围。但在压缩之前，您必须在末尾添加一个额外的值，以便捕获最后一个范围

fun List<Int>.splitByConsecutive(): List<List<Int>> {
    val rangeStarts = mapIndexedNotNull { index, i -> 
        if (index == 0 || i - 1 != this[index - 1]) index else null 
    }
    return (rangeStarts + listOf(size)).zipWithNext(::subList)
}

fun List.splitByContinuous（）：List{
val rangeStarts=mapIndexedNotNull{index，i->
如果（索引==0 | | i-1！=此[索引-1]）索引否则为空
}
return（rangeStarts+listOf（size））.zipWithNext（：：子列表）
}

对于序列，它不需要中间列表，但仍然需要更多步骤：

fun List<Int>.splitByConsecutive(): List<List<Int>> {
    val rangeStarts = asSequence().mapIndexedNotNull { index, i -> 
        if (index == 0 || i - 1 != this[index - 1]) index else null 
    }
    return (rangeStarts + sequenceOf(size)).zipWithNext(::subList).toList()
}

fun List.splitByContinuous（）：List{
val rangeStarts=asSequence（）.mapIndexedNotNull{index，i->
如果（索引==0 | | i-1！=此[索引-1]）索引否则为空
}
return（rangeStarts+sequenceOf（size））.zipWithNext（：：subList.toList（）
}

这里有一种不同的方法，它更紧凑，但效率较低，因为它会创建两个中间的一次性列表

首先，获取与每个连续运行的开始相匹配的索引列表。然后压缩范围开始和结束，以拉出原始列表的相关范围。但在压缩之前，您必须在末尾添加一个额外的值，以便捕获最后一个范围

fun List<Int>.splitByConsecutive(): List<List<Int>> {
    val rangeStarts = mapIndexedNotNull { index, i -> 
        if (index == 0 || i - 1 != this[index - 1]) index else null 
    }
    return (rangeStarts + listOf(size)).zipWithNext(::subList)
}

fun List.splitByContinuous（）：List{
val rangeStarts=mapIndexedNotNull{index，i->
如果（索引==0 | | i-1！=此[索引-1]）索引否则为空
}
return（rangeStarts+listOf（size））.zipWithNext（：：子列表）
}

对于序列，它不需要中间列表，但仍然需要更多步骤：

fun List<Int>.splitByConsecutive(): List<List<Int>> {
    val rangeStarts = asSequence().mapIndexedNotNull { index, i -> 
        if (index == 0 || i - 1 != this[index - 1]) index else null 
    }
    return (rangeStarts + sequenceOf(size)).zipWithNext(::subList).toList()
}

fun List.splitByContinuous（）：List{
val rangeStarts=asSequence（）.mapIndexedNotNull{index，i->
如果（索引==0 | | i-1！=此[索引-1]）索引否则为空
}
return（rangeStarts+sequenceOf（size））.zipWithNext（：：subList.toList（）
}

使用可变列表折叠

。如果元素是连续的，则将其添加到最后一个数组中，否则使用此元素创建新数组

fun getConsecutiveNumbers(srcList: List<Int>): List<List<Int>> {
    return srcList.fold(mutableListOf<MutableList<Int>>()) { acc, i ->
        if (acc.isEmpty() || acc.last().last() != i - 1) {
            acc.add(mutableListOf(i))
        } else acc.last().add(i)
        acc
    }
}

fun getconsutivenumbers（srcList:List）：List{
返回srcList.fold（mutableListOf（））{acc，i->
if（acc.isEmpty（）| | acc.last（）.last（）！=i-1）{
acc.add（可变列表（一））
}else acc.last（）.添加（i）
行政协调会
}
}

使用可变列表折叠

。如果元素是连续的，则将其添加到最后一个数组中，否则使用此元素创建新数组

fun getConsecutiveNumbers(srcList: List<Int>): List<List<Int>> {
    return srcList.fold(mutableListOf<MutableList<Int>>()) { acc, i ->
        if (acc.isEmpty() || acc.last().last() != i - 1) {
            acc.add(mutableListOf(i))
        } else acc.last().add(i)
        acc
    }
}

fun getconsutivenumbers（srcList:List）：List{
返回srcList.fold（mutableListOf（））{acc，i->
if（acc.isEmpty（）| | acc.last（）.last（）！=i-1）{
acc.add（可变列表（一））
}else acc.last（）.添加（i）
行政协调会
}
}