Kotlin 如何使用函数式和更高效的样式重新编写此代码？

说明： 我们得到了一个整数列表，例如

[2,2,0,2,0,3,1,1]

。可以将其视为随时间变化的某些材料的库存。假设指数化从1开始。在时间单元1，我们有两个单位的材料，在时间单元6，我们有3个单位等

我们得到一个固定大小的容器。我们可以一次填一个单位的材料

例如，如果容器的大小为3，并且我们在时间索引1开始填充：

• 在时间索引1中，我们将填充一个单元（即使有2个单元可用）

• 在时间索引2中，我们还将填充1个单元

• 在时间指数3时，没有什么可填充的，因为存在零库存

• 在时间索引4时，我们将填充一个单元。因此，容器已满

目的是为每个可能的时间索引回答这个问题

注：如果没有可用的单位，我们不允许开始填充

我的尝试：

fun givenStartComputeLength（开始：Int，容器化：Int，表：List）：Int{
var howLongItWillTake=-1
累计风险值=0
for（在start INTILE table.size中的索引）{
如果（表[索引]>0）{
累计+=1
}
如果（累计==容器化）{
howLongItWillTake=索引-开始+1
打破
}
}
要花多长时间才能回来
}
有趣的开始长度（containerSize:Int，table:List）：Map{
val startToLength=mutableMapOf（）
for（索引位于1..table.size containerSize+1中）{
如果（表[index-1]！=0）{
val长度=给定的起始计算长度（索引-1，容器化，表格）
startToLength[索引]=长度
}
}
返回起始长度
}
主要内容（）{
val表格=列表（2,2,0,2,0,3,1,1）
//手动分辨率：
///开始时间为1->结束时间为4-->长度为4（即需要4个时间单位）
///开始2-->结束于6-->长度5
///开始4-->结束于7-->长度4
//从6开始-->到8结束-->长度3
println（startsToLengths（3，table））//输出{1=4，2=5，4=4，6=3}
val表2=列表（2,2,0,2,0,3,0,1）
println（startsToLengths（3，表2））//输出{1=4，2=5，4=5，6=-1}
}

---

问题：它可以工作，但我不认为我写的既不是kotlin风格的代码，也不是高效的代码。我认为功能性更强的时装会更好。有什么帮助吗？

我认为制作算法的主要思想是O（table.size），因为现在它是O（table.size**2）。我们可以使用上一步的结果计算下一步的结果，这节省了我们的精力

有以下链接：

/**
*您可以编辑、运行和共享此代码。
*play.kotlinlang.org
*/
主要内容（）{
println（“你好，世界！！！”）
有趣的开始长度（containerSize:Int，table:List）：Map{
val startToLength=mutableMapOf（）
var s=0
变量e=0
val l=表.size-containerSize+1
变量计数=0
var len=0
而（s0）{count++}
e++
莱恩++
如果（计数==容器化）{
起始长度[s+1]=长度
如果（表[s]>0）{count--}
++
莱恩--
打破
}else if（e==表大小）{
起始长度[s+1]=-1
s=l
打破
}
}
}
返回起始长度
}
val表格=列表（2,2,0,2,0,3,1,1）
println（起始长度（3，表））
}

我不清楚我们应该找到什么。看起来您最终得到了一个索引映射到您调用的长度，但只有输入表包含非零值的索引。长度是多少？只要知道输入表中的值是否为零，它们是否完全无关？是的，这些值是无关的，唯一重要的是它是否为零。地图是为每一个开始，它给出了需要多长时间（即索引的数量）。这有帮助吗？完全装满这个容器需要多长时间。例如，我有一个表

[2,2,0,2,0,3,1,1]

，还有一个大小为3的容器。假设我在时间单元1开始填充它（即表中的索引0）。我将在索引0处消耗一个单位（因为

表[0]=2>0

），在单元2处消耗一个单位（索引1），在时间单元3处消耗0个单位（因为

表[2]=0

），然后在时间单元4处消耗一个单位。因此，我在4点结束填充，因为我达到了容器的大小。我从1开始到4结束，花了4-1+1。这就是长度。

/**
 * You can edit, run, and share this code. 
 * play.kotlinlang.org 
 */

fun main() {
    println("Hello, world!!!")
    
    fun startsToLengths(containerSize : Int, table: List<Int>) : Map<Int,Int> {
        
        val startToLength = mutableMapOf<Int,Int>()
        var s = 0
        var e = 0
        val l = table.size-containerSize + 1
        var count = 0 
        var len = 0
        
        while (s < l) {
            
            while (table[s] == 0 && s < l ) { 
                
                s++ 
                
                len--
            }
            
            if (s == l) { break }

            if (e < l ) { e = l }
            
            while (e < table.size) {
                
                if (table[e] > 0) { count++ }
                
                e++
                len++
                
                if (count == containerSize) {
                    
                    startToLength[s+1] = len
                    
                    if (table[s] > 0) { count-- }
                    
                    s++
                    len--
             
                    break
                    
                } else if (e == table.size) {
                    
                    startToLength[s+1] = -1
                    
                    s = l 
                    
                    break
                }
            }
        }

        return startToLength
    }
    val table = listOf(2,2,0,2,0,3,1,1)
    
    println(startsToLengths(3,table)) 
}