Javascript 嵌套for循环-如何忽略某些组合？

我在做某种暴力攻击来解决一个问题。从理论上讲，这是一个有效的解决方案，实际上也是，但它需要相当长的时间

我有7个相互嵌套的for循环，但我只需要“for变量”的组合，其中没有重复的。因此，例如1,2,3,4,5,6,7是允许的，但是1,1,3,4,5,6,7应该被忽略。我当前正在使用一个函数检查数组中的重复项：

然而，我认为如果我能立即忽略这些组合，而不是对每一个组合反复使用该函数，我会过得更好。现在我正在评估14^7=105.413.504个组合，但只有14个nPr 7=17.297.280个组合是必需的

我当前的代码是（其中hgd是重复测试函数，如果没有重复，则返回true）：

---

for（var a=0；a问题在于你在做额外的工作。在
c
循环中，你已经知道
a
和
b
不相等，但你还是要检查。你可以利用c-style
的灵活性进行
循环：

for(var a=0;a<14;a++) {
    for(var b=0;b<14 && b!=a;b++) {
        for(var c=0;c<14 && c!=a && c!=b;c++) {
            ...
        }
    }
}

for（var a=0；a这里要做的是迭代14个离散值列表的所有排列

一般来说，要访问离散事物列表的所有排列，您需要访问列表中的每个元素。对于每个元素，形成一个包含原始列表中所有其他元素的新列表。获取该列表的所有排列，在每个元素前面加上元素，您就得到了原始列表中可以从该pa开始的所有排列关节元素。当你完成所有元素后，你就完成了

当然，查找列表中包含一个元素的所有排列是一项简单的任务

因此我们得到的是这样的东西：

function forEachPermutation(list, operation) {
  function pluckElement(list, index) {
    var e = list[index];
    var l = [];
    for (var i = 0; i < list.length; ++i)
      if (i !== index) l.push(list[i]);
    return { element: e, remainder: l };
  }

  function permute(partial, remainder) {
    if (remainder.length === 0)
      operation(partial);
    else {
      for (var i = 0; i < remainder.length; ++i) {
        var plucked = pluckElement(remainder, i);
        partial.push(plucked.element);
        permute(partial, plucked.remainder);
        partial.length--;
      }
    }
  }

  permute([], list);
}

编辑-如果您只想从原始列表中提取一定数量的值，则必须修改上述内容；请稍候

好的-如果你想传入一个包含14个元素的列表，但是要为14个元素中的7个元素调用“operation”函数，你可以如下修改该函数。外部的“forEachPermutation”函数将接受一个额外的“len”参数，告诉它所需字符串的长度。然后，“permute”函数将检查“partial.length”是否为目标长度，而不是检查空余数

function forEachPermutation(list, len, operation) {
  function pluckElement(list, index) {
    var e = list[index];
    var l = [];
    for (var i = 0; i < list.length; ++i)
      if (i !== index) l.push(list[i]);
    return { element: e, remainder: l };
  }

  function permute(partial, remainder) {
    if (partial.length === len)
      operation(partial);
    else {
      for (var i = 0; i < remainder.length; ++i) {
        var plucked = pluckElement(remainder, i);
        partial.push(plucked.element);
        permute(partial, plucked.remainder);
        partial.length--;
      }
    }
  }

  permute([], list);
}

另一个编辑-如果出于某种原因，您希望在“操作”函数处理每个排列后保存排列，那么我们必须考虑正在使用的部分数组被覆盖的事实。可以更改对“操作”的调用：

if (partial.length === len)
  operation(partial.slice(0));

这会生成“部分”数组的副本，这样每次调用“操作”都会使用自己的数组。当然，这会使过程变慢。
出于某种原因，我在考虑B+树。但不要问我怎么做。我只记得“管道”和“扇出/扇入”处理是否可以存储验证结果（例如，基于id）某个地方？如果可能的话，你可以检查一次并存储该组合是否有效。我认为这很接近，但不完全正确。他不想要集合的所有排列。他想要集合的所有七个元素组合的所有排列。虽然它破坏了上述代码的一般用途，但我认为你可以实现通过将（rements.length==0）条件替换为（rements.length==7），其中7是原始数组的长度减去结果数组所需的基数。此解决方案的空间复杂度是多少？空间复杂度--它永远不会超过“len”一次调用堆栈。如果您正在对数千个元素的列表进行排列，这可能是一个问题，但这样的工作无论如何都会花费很长时间：-）可能可以通过避免这么多新的数组构造来做得更好。“部分”数组实际上可能只是一个传递的数组…也可能有点混乱，很好地发现，你完全正确。然而，这会变得相当混乱，并且确实不能真正概括。
function forEachPermutation(list, len, operation) {
  function pluckElement(list, index) {
    var e = list[index];
    var l = [];
    for (var i = 0; i < list.length; ++i)
      if (i !== index) l.push(list[i]);
    return { element: e, remainder: l };
  }

  function permute(partial, remainder) {
    if (partial.length === len)
      operation(partial);
    else {
      for (var i = 0; i < remainder.length; ++i) {
        var plucked = pluckElement(remainder, i);
        partial.push(plucked.element);
        permute(partial, plucked.remainder);
        partial.length--;
      }
    }
  }

  permute([], list);
}

forEachPermutation([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13], 7, check);

if (partial.length === len)
  operation(partial.slice(0));