Реклинсивная функция Kotlin для сравнения двух массивов и сохранения содержимого исходного массива

Question

Мне нужно сравнить два MutableList, requiredDevices и предоставленных устройств, используя рекурсивную функцию. Эти два MutableList являются элементом MutableList, а также originalArray. Если есть совпадение, он поочередно извлекает соответствующий элемент requiredDevices и provideDevices и добавляет остаток в list1 и list2 соответственно. Как я могу это сделать и сохранить содержимое обязательных устройств и предоставленных устройств и оригинального массива. Например:

originalArray=[requiredDevices, providedDevices]
           =[["A","B","C"],["B,"C","A","A","D"]]

requiredDevices=["A","B","C"]
providedDevices=["B,"C","A","A","D"]

, после рекурсии:

list1=[] (empty array)
list2=["A","D"]

originalArray=[[],["A","D"]]

Попытка написать рекурсивную функцию и взять в качестве аргумента requiredDevices и обеспечитьDevices. Рекурсивная функция возвращает список temp, содержащий list1 и list2. Но requiredDevices и предоставляемые устройства также изменены.

val temp = mutableListOf<MutableList<String>>()
fun compareArray(requiredDevices: MutableList<String>, providedDevices: MutableList<String>): List<MutableList<String>> {

    for (i in 1 until requiredDevices.size) {
        for (j in 0 until providedDevices.size) {

            try {
                if (requiredDevices[i] == providedDevices[j]) {
                    requiredDevices.removeAt(i)
                    providedDevices.removeAt(j)

                    compareArray(requiredDevices, providedDevices)

                    temp.add(requiredDevices)
                    temp.add(providedDevices)
                }
            } catch (e: IndexOutOfBoundsException) {
            }
        }
    }

    return temp.distinct()
}

Я хочу сохранить оригинальное содержимое Array и по-прежнему получать тот же результат, что и list1 и list2. Следующим образом:

originalArray=[["A","B","C"],["B,"C","A","D"]]

Answer 1

Я не очень понимаю, что пытается сделать ваш алгоритм. Исходя из вашего комментария, я думаю, что это решает проблему. При этом два начальных списка копируются в новые списки, а затем удаляются элементы из копий по одному, поэтому они сохраняют лишние элементы, если они у них есть.

fun <T> removeCommonValues(listA: List<T>, listB: List<T>): Pair<List<T>, List<T>> {
    val outA = listA.toMutableList()
    val outB = listB.toMutableList()
    for (i in (outA.size - 1) downTo 0){
        for (j in (outB.size - 1) downTo 0){
            if (outA[i] == outB[j]){
                outA.removeAt(i)
                outB.removeAt(j)
                break
            }
        }
    }

    return outA to outB
}

Тест:

fun main() {
    val required = listOf("A", "B", "C", "C")
    val available = listOf("B", "C", "A", "D", "D")
    println(removeCommonValues(required, available))
}

// Outputs ([C], [D, D])