如何对列表元素两两求和？求Kotlin惯用的两数之和索引解法

首先得明确你需要的是哪种两两组合：无重复的无序配对（比如(1,2)和(2,1)算同一组，且不计算元素与自身的配对），还是所有有序配对（包含正反配对和元素自配对）。

无重复的无序配对（常用场景） #

我们可以结合withIndex()、flatMap和drop()来避免重复计算，这是Kotlin里的惯用写法：

val numbers = listOf(1, 2, 3, 4)
val uniquePairSums = numbers.withIndex().flatMap { (i, num1) ->
    // 从当前元素的下一个位置开始遍历，避免重复配对
    numbers.drop(i + 1).map { num2 -> num1 + num2 }
}
// 结果: [3, 4, 5, 5, 6, 7]

所有有序配对（含重复与自配对） #

如果需要覆盖所有可能的有序组合，直接用两层flatMap+map即可：

val numbers = listOf(1, 2, 3)
val allPairSums = numbers.flatMap { num1 ->
    numbers.map { num2 -> num1 + num2 }
}
// 结果: [2, 3, 4, 3, 4, 5, 4, 5, 6]

先说说你原代码的问题所在：

1. 语法错误：list - 1是无效的Kotlin语法，不能用整数减列表；
2. 索引逻辑错误：你遍历的是元素而非索引，导致list[item]试图用元素值作为索引，很容易触发IndexOutOfBoundsException；
3. 冗余计算：没有避免元素自配对，且会重复检查同一组元素的正反配对；
4. 效率低下：嵌套循环的时间复杂度是O(n²)，不适合处理大列表。

下面是两种符合Kotlin风格的解法，按需选择：

解法1：简单嵌套循环（适合小列表） #

逻辑直观，避免冗余检查，返回的索引自然是从小到大排序的：

fun findSumOfTwo(list: List<Int>, target: Int): Pair<Int, Int> {
    // 遍历每个元素的索引i
    for (i in list.indices) {
        // j从i+1开始，避免重复检查同一对或自配对
        for (j in i + 1 until list.size) {
            if (list[i] + list[j] == target) {
                return Pair(i, j)
            }
        }
    }
    return Pair(-1, -1)
}

解法2：哈希表优化（O(n)时间复杂度，适合大列表） #

用mutableMapOf存储元素与索引的映射，能在常数时间内找到目标补数，是性能更优的方案：

fun findSumOfTwo(list: List<Int>, target: Int): Pair<Int, Int> {
    val indexMap = mutableMapOf<Int, Int>()
    
    list.forEachIndexed { currentIndex, currentNum ->
        val complement = target - currentNum
        // 如果补数已在映射中，直接返回之前的索引和当前索引（顺序天然从小到大）
        indexMap[complement]?.let { previousIndex ->
            return Pair(previousIndex, currentIndex)
        }
        // 补数不存在时，把当前元素和索引存入映射
        indexMap[currentNum] = currentIndex
    }
    
    return Pair(-1, -1)
}

说明：这个解法会返回第一个找到的有效配对。如果列表存在重复元素（比如[3, 3]，目标值6），会正确返回(0, 1)。

内容的提问来源于stack exchange，提问作者rost