Java 整数n作为List的第二个参数传递<；字符串>；。子列表（fromIndex，toIndex），但是stacktrace说toIndex是n+；科特林2号

我正在解决Codewars中的一个问题： 输入是一个字符串数组和一个整数k，输出是最长的字符串，可以通过从数组中连续提取k个元素并将它们连接到字符串来形成。 下面是我针对这个问题的代码，我现在正在测试它

fun main() {

    val array = arrayOf("1", "2", "3", "4", "5", "6", "7")
    println(longestConsec(array, 2))

//    Combinations below don't work either
//    val array = arrayOf("1", "2", "3", "4","5",  "6", "7", "8", "9")
//    println(longestConsec(array, 3))
//
//    val array = arrayOf("1", "2", "3", "4","5",  "6", "7", "8", "9", "10", "11")
//    println(longestConsec(array, 4))

//    val array = arrayOf("1", "2", "3", "4","5",  "6", "7", "8", "9", "10", "11", "12", "13")
//    println(longestConsec(array, 5))

}

fun longestConsec(strings: Array<String>, size: Int) =
    when {
        strings.isEmpty() || size > strings.size || size <= 0 -> ""
        else -> ConsecutiveString(strings.toList(), size)
            .searchLongestConsecutiveString(0, mutableListOf())
            .maxBy { it.length } ?: throw IllegalArgumentException()
    }

class ConsecutiveString(private val originalList: List<String>, private val size: Int) {

    tailrec fun searchLongestConsecutiveString(index: Int, acc: MutableList<String>): List<String> {
        println("start")
        return when {
            index + size >= originalList.size -> acc
            else -> {
                println(index + size)
                // *** doesn't work ***
                searchLongestConsecutiveString(
                    index + 1
                    , acc.apply { add(originalList.subList(index, index + size).joinToString("")) }
                )
                // *** doesn't work ***

                // *** works ***
//                val consecutiveString = originalList.subList(index, index + size).joinToString("")
//                searchLongestConsecutiveString(
//                    index + 1
//                    , acc.apply { add(consecutiveString) }
//                )
                // *** works ***
            }
        }
    }
}

fun main（）{
val数组=数组（“1”、“2”、“3”、“4”、“5”、“6”、“7”）
println（longestcense（数组，2））
//下面的组合也不起作用
//val数组=数组（“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”、“9”）
//println（longestcense（数组，3））
//
//val数组=数组的数组（“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”、“9”、“10”、“11”）
//println（longestcense（数组，4））
//val数组=数组的数组（“1”、“2”、“3”、“4”、“5”、“6”、“7”、“8”、“9”、“10”、“11”、“12”、“13”）
//println（longestcense（数组，5））
}
有趣的长字符串（字符串：数组，大小：Int）=
什么时候{
strings.isEmpty（）| | size>strings.size | | size“”
else->ConcertiveString（strings.toList（），size）
.SearchLongestContinuousInvesting（0，mutableListOf（））
.maxBy{it.length}？：抛出IllegalArgumentException（）
}
类连续性（私有值原始列表：列表，私有值大小：Int）{
tailrec fun SearchLongestContinuousInvestring（索引：Int，附件：可变列表）：列表{
println（“开始”）
何时返回{
索引+大小>=原始列表大小->附件
其他->{
println（索引+大小）
//***不起作用***
搜索最长的连续搜索(
索引+1
，acc.apply{add（originalList.subList（index，index+size）.joinToString（“”））中的
)
//***不起作用***
//***作品***
//val consutivestring=原始列表。子列表（索引，索引+大小）。joinToString（“”）
//搜索最长的连续搜索(
//索引+1
//，acc.apply{添加（连续投资）}
//                )
//***作品***
}
}
}
}

这段代码抛出java.lang.IndexOutOfBoundsException，下面是stacktrace

开始

二,

开始

三,

开始

四,

开始

五,

开始

六,

线程“main”java.lang.IndexOutOfBoundsException中的异常：toIndex=8

位于java.util.ArrayList.subListRangeCheck（ArrayList.java:1010）

在java.util.ArrayList.subList（ArrayList.java:1002）中

搜索最长的连续搜索（CodeWars.kt:37）

Longestcense的CodeWarsKt（CodeWars.kt:22）

在CodeWarsKt.main（CodeWars.kt:4）

在CodeWarsKt.main（CodeWars.kt）

进程已完成，退出代码为1

这里有三件有趣的事情

index+size作为sublist的第二个参数（fromIndex，toIndex）传递，在抛出异常的行之前似乎是6。然而，stacktrace显示toIndex是8，而不是6

如果字符串数组的大小小于N*2+3，则此代码不会引发IndexOutOfBoundsException，其中N是LongestConce（字符串，大小）的第二个参数

如果预先准备好字符串val并将其添加到acc（请参阅上面代码中的注释），而不是使用apply（）并递归地将结果传递给方法，则不会引发异常

我在没有tailrec的情况下尝试了，但结果是一样的

有人能帮我弄清楚这是怎么回事吗

我的环境如下

操作系统：Windows 10 Home

IntelliJ IDEA:2019.2（社区版）11.0.3+12-b304.10 amd64

Kotlin:1.3.41-release-150（JRE 1.8.0_151-b12）

---

IntelliJ Kotlin插件：1.3.50-release-IJ2019.2-1

您调用的

size

内部

acc.apply

。在该范围内，

size

指的是

acc

的大小，而不是

连续投资：：size

避免使用

apply

或使用标签：

this@ConsecutiveString.size

---

或者，我应该更改名称以避免这种混淆。非常感谢你！