最大长度的快速高效排列

Question

我想在 javascript 中创建一个排列函数，它可以非常快速地找到数组的所有排列，以及它之前的每个长度（我将给出一个进一步解释的示例）。它需要尽可能快速和高效，并且不应该有任何重复。例如，该函数将输入一个类似于

的列表

[0, 1, 2]

预期的输出是

[[0], [1], [2], [0, 1], [0, 2], [1, 2], [1, 2, 3]]

数组中不会有任何重复项（例如 [0, 0] 不起作用），并且交换的值也不应该存在（[1, 0] 和 [0, 1] 都不会'不在那里。只有其中一个）。

我查看了this question 和this question，但仍然无法得到我想要的。

最重要的是，这需要尽可能高效（尽可能缩短执行时间）

Answer 1

词汇课：这些实际上是组合，而不是排列。对于排列，不同的顺序是不同的排列。此外，从技术上讲，您想要的并不是所有组合，因为有一个空组合 []，而且您似乎不希望包含它。

不管怎样，这是我准备的东西。

function getCombinations(array) {
    let combinations = [];
    for (let value of array) {
        combinations = combinations
            .concat(combinations.map(value0 => value0.concat([value])))
            .concat([[value]]);
    }
    
    return combinations;
}

console.log(getCombinations([0, 1, 2, 3]))

Answer 2

根据 Mason 的回答，我想我会针对性能进行更多调整，避免使用 Array.prototype.concat() 进行复制的开销，以及使用 for...of 隐式使用 array iterator：

function getCombinations (array) {
  const combinations = [];

  for (let i = 0; i < array.length; ++i) {
    const value = array[i];
    const { length } = combinations;

    combinations.push([value]);

    for (let j = 0; j < length; ++j) {
      const oldCombination = combinations[j];
      const oldLength = oldCombination.length;
      const newCombination = [];

      for (let k = 0; k < oldLength; ++k) {
        newCombination.push(oldCombination[k]);
      }

      newCombination.push(value);
      combinations.push(newCombination);
    }
  }

  return combinations;
}

const input = Array.from({ length: 23 }, (_, i) => i);
const start = performance.now();
getCombinations(input);
console.log(performance.now() - start);

下面，我提供了一个基准来与 Mason 的答案进行比较：

function getCombinationsMason(array) {
  let combinations = [];
  for (let value of array) {
    combinations = combinations
      .concat(combinations.map(value0 => value0.concat([value])))
      .concat([
        [value]
      ]);
  }

  return combinations;
}

function getCombinationsPatrick(array) {
  const combinations = [];

  for (let i = 0; i < array.length; ++i) {
    const value = array[i];
    const {
      length
    } = combinations;

    combinations.push([value]);

    for (let j = 0; j < length; ++j) {
      const oldCombination = combinations[j];
      const oldLength = oldCombination.length;
      const newCombination = [];

      for (let k = 0; k < oldLength; ++k) {
        newCombination.push(oldCombination[k]);
      }

      newCombination.push(value);
      combinations.push(newCombination);
    }
  }

  return combinations;
}

function average(algorithm, input, times) {
  let total = 0;

  for (let i = 0; i < times; ++i) {
    total -= performance.now();
    algorithm(input);
    total += performance.now();
  }

  return `${algorithm.name}(): ${(total / times).toFixed(2)}ms average over ${times} times`;
}

const input = Array.from({
  length: 18
}, (_, i) => i);

console.log('input.length:', input.length);

// randomize order of testing
if (Math.random() > 0.5) {
  // warmup
  average(getCombinationsMason, input, 2);
  average(getCombinationsPatrick, input, 2);
  // benchmark
  console.log(average(getCombinationsMason, input, 20));
  console.log(average(getCombinationsPatrick, input, 20));
} else {
  // warmup
  average(getCombinationsPatrick, input, 2);
  average(getCombinationsMason, input, 2);
  // benchmark
  console.log(average(getCombinationsPatrick, input, 20));
  console.log(average(getCombinationsMason, input, 20));
}