Question

我有一个ArrayList元素，我需要获取成对的组合。

例如[A, B, C]将转换为[[A, B], [A, C], [B, C]]

我目前使用通常的方法来实现这一目标

for(i in 0 until arr.size-1)
    for(j in i+1 until arr.size)
        //do stuff with arr[i], arr[j]

并且，如果我需要两个以上元素的组合，我可能会编写一个递归函数来执行相同的操作。我担心的是，这种方法仍然过时，可能不像Functional-Kotlin那样

是否有更好的方法来实现这一目标，并且还可以将更多的元素组合在一起而无需递归？

Answer 1

要使功能更加实用，您可以做的一件事就是使成对生产与其消耗脱钩。

可以使用函数sequence编写对生成器：

fun <T> elementPairs(arr: List<T>): Sequence<Pair<T, T>> = sequence {
    for(i in 0 until arr.size-1)
        for(j in i+1 until arr.size)
            yield(arr[i] to arr[j])
}

然后，您可以使用该序列并以不同的方式处理配对，例如

fun main() {
    elementPairs(listOf('A', 'B', 'C', 'D')).forEach {
        println(it)
    }

    elementPairs(listOf("apple", "desk", "arc", "density", "array"))
        .filter { (a, b) -> a.first() == b.first() }
        .forEach { println("Starting with the same letter: $it") }
}

您可以在这里尝试：https://pl.kotl.in/dJ9mAiATc

Answer 2

因此，接受的答案会创建配对。我创建了一个对象，该对象可以使用不超过items.size -1

的任何长度组合

class CombinationGenerator<T>(private val items: List<T>, choose: Int = 1) : Iterator<List<T>>, Iterable<List<T>> {
    private val indices = Array(choose) { it }
    private var first = true

    init {
        if (items.isEmpty() || choose > items.size || choose < 1)
            error("list must have more than 'choose' items and 'choose' min is 1")
    }

    override fun hasNext(): Boolean = indices.filterIndexed { index, it ->
        when (index) {
            indices.lastIndex -> items.lastIndex > it
            else -> indices[index + 1] - 1 > it
        }
    }.any()

    override fun next(): List<T> {
        if (!hasNext()) error("AINT NO MORE WHA HAPPEN")
        if (!first) {
            incrementAndCarry()
        } else
            first = false
        return List(indices.size) { items[indices[it]] }
    }

    private fun incrementAndCarry() {
        var carry = false
        var place = indices.lastIndex
        do {
            carry = if ((place == indices.lastIndex && indices[place] < items.lastIndex)
                    || (place != indices.lastIndex && indices[place] < indices[place + 1] - 1)) {
                indices[place]++
                (place + 1..indices.lastIndex).forEachIndexed { index, i ->
                    indices[i] = indices[place] + index + 1
                }
                false
            } else
                true
            place--
        } while (carry && place > -1)
    }

    override fun iterator(): Iterator<List<T>> = this
}

fun main() {
    val combGen = CombinationGenerator(listOf(1, 2, 3, 4), 3)
    combGen.map { println(it.joinToString()) }

}

Answer 3

val arr = intArrayOf(1, 2, 3, 4) //test array

arr.indices.forEach() {
    i -> arr.indices.minus(0..i).forEach() {
    j -> println("${arr[i]} ${arr[j]}") } }

输出

Answer 4

val arr = arrayListOf("A", "B", "C", "D")
val list= mutableListOf<Pair<String, String>>()

arr.indices.forEach() { 
    i -> arr.indices.minus(0..i).forEach() { 
    j -> list.add(arr[i] to arr[j]) }
}
println(list)

输出

[(A, B), (A, C), (A, D), (B, C), (B, D), (C, D)]

在ArrayList中组合元素[Kotlin]

4 个答案: