Question

鉴于此输入[3,1,2]，我想拥有此输出[ [ 1, 1 ], [ 1, 2 ], [ 1, 3 ], [ 2, 2 ], [ 2, 3 ], [ 3, 3 ] ]

其唯一对（[1,2] == [2,1]）

目前我已经做到了

const arr = [3,1,2];
const pairBuilder = (left, index, collection) =>
  collection.slice(index).map(right => [left, right]);

const pairs = arr.sort().flatMap(pairBuilder);
console.log(pairs)

此代码可以正常工作，但是我想知道是否有更好的方法（就性能而言）？我虽然使用lodash来改善排序/映射（使用chain），但是我的问题更多是关于算法改进。

Answer 1

您可以将Generator与function*一起使用，并对数组进行切片以仅获取唯一对。

function* getPairs(array, left) {
    var i = 0;
    while (i < array.length) {
        if (left) yield [left, array[i]];
        else yield* getPairs(array.slice(i), array[i]);
        i++;
    }
}

var array = [1, 2, 3];

console.log([...getPairs(array)]);

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

经典方法。

function getPairs(array) {
    var i, j, result = [];
    for (i = 0; i < array.length; i++) {
        for (j = i; j < array.length; j++) {
            result.push([array[i], array[j]]);
        }
    }
    return result;
}

var array = [1, 2, 3];

console.log(getPairs(array));

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

Answer 2

这是一种幼稚且缓慢的方法。但是我相信它比问题中接受的答案更快。它产生的新对象开销更少，所需的内存也更少。天真的算法不使用递归。因此不会面临递归限制（默认为50）我也相信它仍然可读并且易于理解

        const inp = [3, 1,2];

        function genPair(inp) {
            const length = inp.length;
            const sorted = inp.sort();
            const result = [];
            for (let i = 0; i < length; i++) {
                for (let j = i; j < length; j++) {
                    result.push([sorted[i], sorted[j]]);
                }

            }
            return result;
        }
        const r = genPair(inp);
        console.log(r);

链接到js性能 https://jsperf.com/find-dups/1 在IE11中接受的答案要慢60％，在Chrome中要接受的答案慢10％

在数组中查找唯一的对

2 个答案: