从数组中，生成所有不同的、非空的子数组，并保持顺序

问题描述

我有一个带有子数组的数组，需要一种算法来生成子数组的所有可能的不同组合.结果组合可以是任何长度.例如，如果 Array 有 4 个子数组，则第一个子数组本身将是唯一且有效的结果组合，任何长度的任何其他唯一组合也是如此.

I have an array, with subarrays and need an algorithm that generates all possible distinct combinations of the subarrays. The resultant combinations can be any length. For example, if the Array has 4 subarrays, the first subarray by itself would be a unique and valid resultant combination, as would any other unique combination of any length.

与具有不同顺序的相同项目的子数组的组合不会被认为是唯一的.

A combination with the sub-array with the same items in a different order would not be considered unique.

let mainArray = [[0.3, 1], [0.5, 2], [0.6, 3], [0.3, 4]]

// Valid resultant combinations:
[[0.3, 1]]
[[0.3, 1], [0.5, 2]]
[[0.3, 1], [0.5, 2], [0.6, 3]]
[[0.3, 1], [0.5, 2], [0.6, 3], [0.3, 4]]
[[0.5, 2]]
[[0.5, 2], [0.6, 3]]
[[0.5, 2], [0.6, 3], [0.3, 4]]
[[0.6, 3]]
[[0.6, 3], [0.3, 4]]
[[0.3, 4]]
[[0.3, 1], [0.6, 3], [0.3, 4]]
[[0.3, 1], [0.5, 2], [0.3, 4]]
[[0.3, 1], [0.3, 4]]
[[0.3, 1], [0.6, 3]]
[[0.5, 2], [0.3, 4]]

// Don’t think I missed any.

推荐答案

为了更方便的处理，您可以获取一个索引数组并编写获取所有组合的代码.

For a more convenient handling, you could take an array of indices and write the code for getting all combinations.

稍后，您可以将数组替换为实际值的索引.

Later, you could replace the array with indices by the real values.

这种方法适用于保留收集项目数组和索引的recusion，该索引指向移交的数组.

This approach works with a recusion which keeps an array of collected items and an index, which points to the handed over array.

在开始时，您有一个标准的退出条件，它检查索引是否大于可能，并将收集的值添加到结果集中.

At start, you have a standard exit condition of a recusion which checks if the index is greater than possible and adds the collected values to the result set.

以下部分再次调用该函数，使用先前收集的值和数组中的新值以及递增的索引，以及仅更改索引的另一个调用(此处未使用实际项目).

The following part calls the function again with the peviously collected value and a new value from the array and an incremented index and with aother call with only a changed index (here, the actual item is not used).

function getCombinations(array) {
    function iter(temp, index) {
        if (index >= array.length) {
            result.push(temp);
            return;
        }

        iter([...temp, array[index]], index + 1);
        iter(temp, index + 1);
    }
    
    var result = [];
    iter([], 0);
    return result;
}

let array = [[0.3, 1], [0.5, 2], [0.6, 3], [0.3, 4]];

console.log('indices')
getCombinations([...array.keys()]).forEach(a => console.log(...a));
console.log('arrays')
getCombinations(array).forEach(a => console.log(...a.map(b => JSON.stringify(b))));

.as-console-wrapper { max-height: 100% !important; top: 0; }

这篇关于从数组中，生成所有不同的、非空的子数组，并保持顺序的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持跟版网！