blocks|key|234029|text|如果您注意到了，在进行任何排列之前，代码实际上将字符拆分到一个数组中，因此您只需删除连接和拆分操作|type|unstyled|depth|inlineStyleRanges|entityRanges|data|234030|​|234031|var+permArr+=+[],
++usedChars+=+[];

function+permute(input)+{
++var+i,+ch;
++for+(i+=+0;+i+<+input.length;+i%2B%2B)+{
++++ch+=+input.splice(i,+1)[0];
++++usedChars.push(ch);
++++if+(input.length+==+0)+{
++++++permArr.push(usedChars.slice());
++++}
++++permute(input);
++++input.splice(i,+0,+ch);
++++usedChars.pop();
++}
++return+permArr
};


document.write(JSON.stringify(permute([5,+3,+7,+1])));|code-block|syntax|javascript|234032|234033|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>If you notice, the code actually splits the chars into an array prior to do any permutation, so you simply remove the join and split operation</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="false" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var permArr = [],
  usedChars = [];

function permute(input) {
  var i, ch;
  for (i = 0; i &lt; input.length; i++) {
    ch = input.splice(i, 1)[0];
    usedChars.push(ch);
    if (input.length == 0) {
      permArr.push(usedChars.slice());
    }
    permute(input);
    input.splice(i, 0, ch);
    usedChars.pop();
  }
  return permArr
};


document.write(JSON.stringify(permute([5, 3, 7, 1])));</code></pre>
</div>
</div>
</p>


blocks|key|235595|text|我改进了SiGanteng的answer。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|235596|现在可以多次调用permute，因为每次都会清除permArr和usedChars。|style|CODE|235597|function+permute(input)+{
++++var+permArr+=+[],
++++++++usedChars+=+[];
++++return+(function+main()+{
++++++++for+(var+i+=+0;+i+<+input.length;+i%2B%2B)+{
++++++++++++var+ch+=+input.splice(i,+1)[0];
++++++++++++usedChars.push(ch);
++++++++++++if+(input.length+==+0)+{
++++++++++++++++permArr.push(usedChars.slice());
++++++++++++}
++++++++++++main();
++++++++++++input.splice(i,+0,+ch);
++++++++++++usedChars.pop();
++++++++}
++++++++return+permArr;
++++})();
}|code-block|syntax|javascript|235598|​|235599|function+permute(input)+{
++var+permArr+=+[],
++++++usedChars+=+[];
++return+(function+main()+{
++++for+(var+i+=+0;+i+<+input.length;+i%2B%2B)+{
++++++var+ch+=+input.splice(i,+1)[0];
++++++usedChars.push(ch);
++++++if+(input.length+==+0)+{
++++++++permArr.push(usedChars.slice());
++++++}
++++++main();
++++++input.splice(i,+0,+ch);
++++++usedChars.pop();
++++}
++++return+permArr;
++})();
}
document.write(JSON.stringify(permute([5,+3,+7,+1])));|235600|235601|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/135448/siganteng|1|https://stackoverflow.com/a/9960925/1529630^0|4|9|0|E|6|1|0|8|7|O|7|W|9|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]|$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|6|7|18|8|@$A|19|B|1A|F|G]|$A|1B|B|1C|F|G]|$A|1D|B|1E|F|G]]|9|@]|C|$]]|$1|H|3|I|5|J|7|1F|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1G|8|@]|9|@]|C|$]]|$1|O|3|P|5|J|7|1H|8|@]|9|@]|C|$K|L]]|$1|Q|3|N|5|6|7|1I|8|@]|9|@]|C|$]]|$1|R|3|-4|5|6|7|1J|8|@]|9|@]|C|$]]]|S|$T|$5|U|V|W|C|$X|Y]]|Z|$5|U|V|W|C|$X|10]]]]

<p>I have improved <a href="https://stackoverflow.com/users/135448/siganteng">SiGanteng</a>'s <a href="https://stackoverflow.com/a/9960925/1529630">answer</a>.</p>

<p>Now it is possible to call <code>permute</code> more than once, because <code>permArr</code> and <code>usedChars</code> are cleared each time.</p>

<pre class="lang-js prettyprint-override"><code>function permute(input) {
    var permArr = [],
        usedChars = [];
    return (function main() {
        for (var i = 0; i &lt; input.length; i++) {
            var ch = input.splice(i, 1)[0];
            usedChars.push(ch);
            if (input.length == 0) {
                permArr.push(usedChars.slice());
            }
            main();
            input.splice(i, 0, ch);
            usedChars.pop();
        }
        return permArr;
    })();
}
</code></pre>

<p><div class="snippet" data-lang="js" data-hide="true" data-console="false" data-babel="false">
<div class="snippet-code snippet-currently-hidden">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function permute(input) {
  var permArr = [],
      usedChars = [];
  return (function main() {
    for (var i = 0; i &lt; input.length; i++) {
      var ch = input.splice(i, 1)[0];
      usedChars.push(ch);
      if (input.length == 0) {
        permArr.push(usedChars.slice());
      }
      main();
      input.splice(i, 0, ch);
      usedChars.pop();
    }
    return permArr;
  })();
}
document.write(JSON.stringify(permute([5, 3, 7, 1])));</code></pre>
</div>
</div>
</p>


blocks|key|230209|text|下面的函数对任何类型的数组进行置换，并对找到的每个置换调用指定的回调函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|230210|/*
++Permutate+the+elements+in+the+specified+array+by+swapping+them
++in-place+and+calling+the+specified+callback+function+on+the+array
++for+each+permutation.

++Return+the+number+of+permutations.

++If+array+is+undefined,+null+or+empty,+return+0.

++NOTE:+when+permutation+succeeds,+the+array+should+be+in+the+original+state
++on+exit!
*/
++function+permutate(array,+callback)+{
++++//+Do+the+actual+permuation+work+on+array[],+starting+at+index
++++function+p(array,+index,+callback)+{
++++++//+Swap+elements+i1+and+i2+in+array+a[]
++++++function+swap(a,+i1,+i2)+{
++++++++var+t+=+a[i1];
++++++++a[i1]+=+a[i2];
++++++++a[i2]+=+t;
++++++}

++++++if+(index+==+array.length+-+1)+{
++++++++callback(array);
++++++++return+1;
++++++}+else+{
++++++++var+count+=+p(array,+index+%2B+1,+callback);
++++++++for+(var+i+=+index+%2B+1;+i+<+array.length;+i%2B%2B)+{
++++++++++swap(array,+i,+index);
++++++++++count+%2B=+p(array,+index+%2B+1,+callback);
++++++++++swap(array,+i,+index);
++++++++}
++++++++return+count;
++++++}
++++}

++++if+(!array+%7C%7C+array.length+==+0)+{
++++++return+0;
++++}
++++return+p(array,+0,+callback);
++}|code-block|syntax|javascript|230211|如果你这样称呼它：|230212|++//+Empty+array+to+hold+results
++var+result+=+[];
++//+Permutate+[1,+2,+3],+pushing+every+permutation+onto+result[]
++permutate([1,+2,+3],+function+(a)+{
++++//+Create+a+copy+of+a[]+and+add+that+to+result[]
++++result.push(a.slice(0));
++});
++//+Show+result[]
++document.write(result);|230213|我认为它会做你需要做的事情-用数组1，2，3的排列填充一个名为result的数组。结果是：|offset|length|style|CODE|230214|[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,2,1],[3,1,2]]|230215|JSFiddle上的代码稍微清晰一些：http://jsfiddle.net/MgmMg/6/|230216|entityMap|0|LINK|mutability|MUTABLE|url|http://jsfiddle.net/MgmMg/6/^0|0|0|0|0|V|6|0|0|J|S|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|16|8|@$M|17|N|18|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1A|8|@]|9|@$M|1B|N|1C|1|1D]]|A|$]]|$1|U|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

<p>The following function permutates an array of any type and calls a specified callback function on each permutation found:</p>

<pre><code>/*
  Permutate the elements in the specified array by swapping them
  in-place and calling the specified callback function on the array
  for each permutation.

  Return the number of permutations.

  If array is undefined, null or empty, return 0.

  NOTE: when permutation succeeds, the array should be in the original state
  on exit!
*/
  function permutate(array, callback) {
    // Do the actual permuation work on array[], starting at index
    function p(array, index, callback) {
      // Swap elements i1 and i2 in array a[]
      function swap(a, i1, i2) {
        var t = a[i1];
        a[i1] = a[i2];
        a[i2] = t;
      }

      if (index == array.length - 1) {
        callback(array);
        return 1;
      } else {
        var count = p(array, index + 1, callback);
        for (var i = index + 1; i &lt; array.length; i++) {
          swap(array, i, index);
          count += p(array, index + 1, callback);
          swap(array, i, index);
        }
        return count;
      }
    }

    if (!array || array.length == 0) {
      return 0;
    }
    return p(array, 0, callback);
  }
</code></pre>

<p>If you call it like this:</p>

<pre><code>  // Empty array to hold results
  var result = [];
  // Permutate [1, 2, 3], pushing every permutation onto result[]
  permutate([1, 2, 3], function (a) {
    // Create a copy of a[] and add that to result[]
    result.push(a.slice(0));
  });
  // Show result[]
  document.write(result);
</code></pre>

<p>I think it will do exactly what you need - fill an array called <code>result</code> with the permutations of the array [1, 2, 3]. The result is:</p>

<pre><code>[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,2,1],[3,1,2]]
</code></pre>

<p>Slightly clearer code on JSFiddle: <a href="http://jsfiddle.net/MgmMg/6/" rel="noreferrer">http://jsfiddle.net/MgmMg/6/</a></p>


blocks|key|233089|text|有点晚了，但我想在这里添加一个更优雅的版本。可以是任何数组..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|233090|function+permutator(inputArr)+{
++var+results+=+[];

++function+permute(arr,+memo)+{
++++var+cur,+memo+=+memo+%7C%7C+[];

++++for+(var+i+=+0;+i+<+arr.length;+i%2B%2B)+{
++++++cur+=+arr.splice(i,+1);
++++++if+(arr.length+===+0)+{
++++++++results.push(memo.concat(cur));
++++++}
++++++permute(arr.slice(),+memo.concat(cur));
++++++arr.splice(i,+0,+cur[0]);
++++}

++++return+results;
++}

++return+permute(inputArr);
}|code-block|syntax|javascript|233091|添加ES6+(2015)版本。也不会改变原始输入数组。在Chrome的控制台中工作...|233092|const+permutator+=+(inputArr)+=>+{
++let+result+=+[];

++const+permute+=+(arr,+m+=+[])+=>+{
++++if+(arr.length+===+0)+{
++++++result.push(m)
++++}+else+{
++++++for+(let+i+=+0;+i+<+arr.length;+i%2B%2B)+{
++++++++let+curr+=+arr.slice();
++++++++let+next+=+curr.splice(i,+1);
++++++++permute(curr.slice(),+m.concat(next))
+++++}
+++}
+}

+permute(inputArr)

+return+result;
}|233093|所以..。|233094|permutator(['c','a','t']);|233095|收益率...|233096|[+[+'c',+'a',+'t'+],
++[+'c',+'t',+'a'+],
++[+'a',+'c',+'t'+],
++[+'a',+'t',+'c'+],
++[+'t',+'c',+'a'+],
++[+'t',+'a',+'c'+]+]|233097|还有..。|233098|permutator([1,2,3]);|233099|233100|[+[+1,+2,+3+],
++[+1,+3,+2+],
++[+2,+1,+3+],
++[+2,+3,+1+],
++[+3,+1,+2+],
++[+3,+2,+1+]+]|233101|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|13|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|15|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|17|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|18|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|19|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|W|3|P|5|6|7|1B|8|@]|9|@]|A|$]]|$1|X|3|Y|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|Z|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|10|$]]

<p>Little late, but like to add a slightly more elegant version here.  Can be any array...</p>

<pre><code>function permutator(inputArr) {
  var results = [];

  function permute(arr, memo) {
    var cur, memo = memo || [];

    for (var i = 0; i &lt; arr.length; i++) {
      cur = arr.splice(i, 1);
      if (arr.length === 0) {
        results.push(memo.concat(cur));
      }
      permute(arr.slice(), memo.concat(cur));
      arr.splice(i, 0, cur[0]);
    }

    return results;
  }

  return permute(inputArr);
}
</code></pre>

<p>Adding an ES6 (2015) version. Also does not mutate the original input array. Works in the console in Chrome...</p>

<pre><code>const permutator = (inputArr) =&gt; {
  let result = [];

  const permute = (arr, m = []) =&gt; {
    if (arr.length === 0) {
      result.push(m)
    } else {
      for (let i = 0; i &lt; arr.length; i++) {
        let curr = arr.slice();
        let next = curr.splice(i, 1);
        permute(curr.slice(), m.concat(next))
     }
   }
 }

 permute(inputArr)

 return result;
}
</code></pre>

<p>So...</p>

<pre><code>permutator(['c','a','t']);
</code></pre>

<p>Yields...</p>

<pre><code>[ [ 'c', 'a', 't' ],
  [ 'c', 't', 'a' ],
  [ 'a', 'c', 't' ],
  [ 'a', 't', 'c' ],
  [ 't', 'c', 'a' ],
  [ 't', 'a', 'c' ] ]
</code></pre>

<p>And...</p>

<pre><code>permutator([1,2,3]);
</code></pre>

<p>Yields...</p>

<pre><code>[ [ 1, 2, 3 ],
  [ 1, 3, 2 ],
  [ 2, 1, 3 ],
  [ 2, 3, 1 ],
  [ 3, 1, 2 ],
  [ 3, 2, 1 ] ]
</code></pre>


blocks|key|235635|text|var+inputArray+=+[1,+2,+3];

var+result+=+inputArray.reduce(function+permute(res,+item,+key,+arr)+{
++++return+res.concat(arr.length+>+1+&&+arr.slice(0,+key).concat(arr.slice(key+%2B+1)).reduce(permute,+[]).map(function(perm)+{+return+[item].concat(perm);+})+%7C%7C+item);
},+[]);


alert(JSON.stringify(result));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|235636|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>var inputArray = [1, 2, 3];

var result = inputArray.reduce(function permute(res, item, key, arr) {
    return res.concat(arr.length &gt; 1 &amp;&amp; arr.slice(0, key).concat(arr.slice(key + 1)).reduce(permute, []).map(function(perm) { return [item].concat(perm); }) || item);
}, []);


alert(JSON.stringify(result));
</code></pre>


blocks|key|3108305|text|我对这个网站的第一个贡献。此外，根据我所做的测试，此代码的运行速度比这里提到的所有其他方法都要快，当然，如果值很少，它就会很少，但当添加太多值时，时间会成倍增加。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3108306|​|3108307|var+result+=+permutations([1,2,3,4]);

var+output+=+window.document.getElementById('output');
output.innerHTML+=+JSON.stringify(result);

function+permutations(arr)+{
++++var+finalArr+=+[];
++++function+iterator(arrayTaken,+tree)+{
++++++++var+temp;
++++++++for+(var+i+=+0;+i+<+tree;+i%2B%2B)+{
++++++++++++temp+=+arrayTaken.slice();
++++++++++++temp.splice(tree+-+1+-+i,+0,+temp.splice(tree+-+1,+1)[0]);
++++++++++++if+(tree+>=+arr.length)+{
++++++++++++++++finalArr.push(temp);
++++++++++++}+else+{
++++++++++++++++iterator(temp,+tree+%2B+1);
++++++++++++}
++++++++}
++++}
++++iterator(arr,+1);
++++return+finalArr;
};|code-block|syntax|javascript|3108308|<div+id="output"></div>|3108309|3108310|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|P|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|K|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|M|$]]

<p>My first contribution to the site. Also, according to the tests that I have done, this code runs faster than all the other methods mentioned here before this date, of course it is minimal if there are few values, but the time increases exponentially when adding too many.</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>var result = permutations([1,2,3,4]);

var output = window.document.getElementById('output');
output.innerHTML = JSON.stringify(result);

function permutations(arr) {
    var finalArr = [];
    function iterator(arrayTaken, tree) {
        var temp;
        for (var i = 0; i &lt; tree; i++) {
            temp = arrayTaken.slice();
            temp.splice(tree - 1 - i, 0, temp.splice(tree - 1, 1)[0]);
            if (tree &gt;= arr.length) {
                finalArr.push(temp);
            } else {
                iterator(temp, tree + 1);
            }
        }
    }
    iterator(arr, 1);
    return finalArr;
};</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;div id="output"&gt;&lt;/div&gt;</code></pre>
</div>
</div>
</p>


blocks|key|2894523|text|无需外部数组或附加函数即可回答|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2894524|function+permutator+(arr)+{
++var+permutations+=+[];
++if+(arr.length+===+1)+{
++++return+[+arr+];
++}

++for+(var+i+=+0;+i+<++arr.length;+i%2B%2B)+{+
++++var+subPerms+=+permutator(arr.slice(0,+i).concat(arr.slice(i+%2B+1)));
++++for+(var+j+=+0;+j+<+subPerms.length;+j%2B%2B)+{
++++++subPerms[j].unshift(arr[i]);
++++++permutations.push(subPerms[j]);
++++}
++}
++return+permutations;
}|code-block|syntax|javascript|2894525|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Answer without the need for a exterior array or additional function</p>

<pre><code>function permutator (arr) {
  var permutations = [];
  if (arr.length === 1) {
    return [ arr ];
  }

  for (var i = 0; i &lt;  arr.length; i++) { 
    var subPerms = permutator(arr.slice(0, i).concat(arr.slice(i + 1)));
    for (var j = 0; j &lt; subPerms.length; j++) {
      subPerms[j].unshift(arr[i]);
      permutations.push(subPerms[j]);
    }
  }
  return permutations;
}
</code></pre>


blocks|key|235656|text|这是另一个“更递归”的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|235657|​|235658|function+perms(input)+{
++var+data+=+input.slice();
++var+permutations+=+[];
++var+n+=+data.length;

++if+(n+===+0)+{
++++return+[
++++++[]
++++];
++}+else+{
++++var+first+=+data.shift();
++++var+words+=+perms(data);
++++words.forEach(function(word)+{
++++++for+(var+i+=+0;+i+<+n;+%2B%2Bi)+{
++++++++var+tmp+=+word.slice();
++++++++tmp.splice(i,+0,+first)
++++++++permutations.push(tmp);
++++++}
++++});
++}

++return+permutations;
}

var+str+=+'ABC';
var+chars+=+str.split('');
var+result+=+perms(chars).map(function(p)+{
++return+p.join('');
});

console.log(result);

var+output+=+window.document.getElementById('output');
output.innerHTML+=+result;|code-block|syntax|javascript|235659|<div+id="output"></div>|235660|235661|输出：|235662|[+'ABC',+'BAC',+'BCA',+'ACB',+'CAB',+'CBA'+]|235663|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|K|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|W|8|@]|9|@]|A|$]]|$1|N|3|O|5|F|7|X|8|@]|9|@]|A|$G|H]]|$1|P|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|Q|$]]

<p>Here is another &quot;more recursive&quot; solution.</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="false" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function perms(input) {
  var data = input.slice();
  var permutations = [];
  var n = data.length;

  if (n === 0) {
    return [
      []
    ];
  } else {
    var first = data.shift();
    var words = perms(data);
    words.forEach(function(word) {
      for (var i = 0; i &lt; n; ++i) {
        var tmp = word.slice();
        tmp.splice(i, 0, first)
        permutations.push(tmp);
      }
    });
  }

  return permutations;
}

var str = 'ABC';
var chars = str.split('');
var result = perms(chars).map(function(p) {
  return p.join('');
});

console.log(result);

var output = window.document.getElementById('output');
output.innerHTML = result;</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;div id="output"&gt;&lt;/div&gt;</code></pre>
</div>
</div>
</p>
<p>Output:</p>
<pre><code>[ 'ABC', 'BAC', 'BCA', 'ACB', 'CAB', 'CBA' ]
</code></pre>


blocks|key|235673|text|我编写了一个post来演示如何在JavaScript中对数组进行置换。下面是执行此操作的代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|235674|var+count=0;
function+permute(pre,cur){+
++++var+len=cur.length;
++++for(var+i=0;i<len;i%2B%2B){
++++++++var+p=clone(pre);
++++++++var+c=clone(cur);
++++++++p.push(cur[i]);
++++++++remove(c,cur[i]);
++++++++if(len>1){
++++++++++++permute(p,c);
++++++++}else{
++++++++++++print(p);
++++++++++++count%2B%2B;
++++++++}
++++}
}
function+print(arr){
++++var+len=arr.length;
++++for(var+i=0;i<len;i%2B%2B){
++++++++document.write(arr[i]%2B"+");
++++}
++++document.write("<br+/>");
}
function+remove(arr,item){
++++if(contains(arr,item)){
++++++++var+len=arr.length;
++++++++for(var+i+=+len-1;+i+>=+0;+i--){+//+STEP+1
++++++++++++if(arr[i]+==+item){+++++++++++++//+STEP+2
++++++++++++++++arr.splice(i,1);++++++++++++++//+STEP+3
++++++++++++}
++++++++}
++++}
}
function+contains(arr,value){
++++for(var+i=0;i<arr.length;i%2B%2B){
++++++++if(arr[i]==value){
++++++++++++return+true;
++++++++}
++++}
++++return+false;
}
function+clone(arr){
++++var+a=new+Array();
++++var+len=arr.length;
++++for(var+i=0;i<len;i%2B%2B){
++++++++a.push(arr[i]);
++++}
++++return+a;
}|code-block|syntax|javascript|235675|只要打个电话|235676|235677|置换([]，1,2,3,4)|blockquote|235678|235679|235680|都会起作用的。有关这是如何工作的详细信息，请参考该帖子中的解释。|235681|entityMap|0|LINK|mutability|MUTABLE|url|http://www.pixelstech.net/article/1316620955-Permutation-algorithm-with-JavaScript^0|6|4|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|16|8|@]|9|@]|C|$]]|$1|L|3|M|5|N|7|17|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|18|8|@]|9|@]|C|$]]|$1|P|3|-4|5|6|7|19|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1A|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

<p>I wrote a <a href="http://www.pixelstech.net/article/1316620955-Permutation-algorithm-with-JavaScript" rel="nofollow">post</a> to demonstrate how to permute an array in JavaScript. Here is the code which does this.</p>

<pre><code>var count=0;
function permute(pre,cur){ 
    var len=cur.length;
    for(var i=0;i&lt;len;i++){
        var p=clone(pre);
        var c=clone(cur);
        p.push(cur[i]);
        remove(c,cur[i]);
        if(len&gt;1){
            permute(p,c);
        }else{
            print(p);
            count++;
        }
    }
}
function print(arr){
    var len=arr.length;
    for(var i=0;i&lt;len;i++){
        document.write(arr[i]+" ");
    }
    document.write("&lt;br /&gt;");
}
function remove(arr,item){
    if(contains(arr,item)){
        var len=arr.length;
        for(var i = len-1; i &gt;= 0; i--){ // STEP 1
            if(arr[i] == item){             // STEP 2
                arr.splice(i,1);              // STEP 3
            }
        }
    }
}
function contains(arr,value){
    for(var i=0;i&lt;arr.length;i++){
        if(arr[i]==value){
            return true;
        }
    }
    return false;
}
function clone(arr){
    var a=new Array();
    var len=arr.length;
    for(var i=0;i&lt;len;i++){
        a.push(arr[i]);
    }
    return a;
}
</code></pre>

<p>Just call </p>

<blockquote>
  <p>permute([], [1,2,3,4])</p>
</blockquote>

<p>will work. For details on how this works, please refer to the explanation in that post.</p>


blocks|key|233165|text|受Haskell启发的一些版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|233166|perms+[]+=+[[]]
perms+xs+=+[+x:ps+%7C+x+<-+xs+,+ps+<-+perms+(+xs\\[x]+)+]|code-block|syntax|javascript|233167|​|233168|function+perms(xs)+{
++if+(!xs.length)+return+[[]];
++return+xs.flatMap(x+=>+{
++++//+get+permutations+of+xs+without+x,+then+prepend+x+to+each
++++return+perms(xs.filter(v+=>+v!==x)).map(vs+=>+[x,+...vs]);
++});
++//+or+this+duplicate-safe+way,+suggested+by+@M.Charbonnier+in+the+comments
++//+return+xs.flatMap((x,+i)+=>+{
++//+++return+perms(xs.filter((v,+j)+=>+i!==j)).map(vs+=>+[x,+...vs]);
++//+});
++//+or+@user3658510's+variant
++//+return+xs.flatMap((x,+i)+=>+{
++//+++return+perms([...xs.slice(0,i),...xs.slice(i%2B1)]).map(vs+=>+[x,...vs]);
++//+});
}
document.write(JSON.stringify(perms([1,2,3])));|233169|233170|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|O|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|P|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|K|3|H|5|6|7|R|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|M|$]]

<p>Some version inspired from Haskell:</p>
<pre><code>perms [] = [[]]
perms xs = [ x:ps | x &lt;- xs , ps &lt;- perms ( xs\\[x] ) ]
</code></pre>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="false" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function perms(xs) {
  if (!xs.length) return [[]];
  return xs.flatMap(x =&gt; {
    // get permutations of xs without x, then prepend x to each
    return perms(xs.filter(v =&gt; v!==x)).map(vs =&gt; [x, ...vs]);
  });
  // or this duplicate-safe way, suggested by @M.Charbonnier in the comments
  // return xs.flatMap((x, i) =&gt; {
  //   return perms(xs.filter((v, j) =&gt; i!==j)).map(vs =&gt; [x, ...vs]);
  // });
  // or @user3658510's variant
  // return xs.flatMap((x, i) =&gt; {
  //   return perms([...xs.slice(0,i),...xs.slice(i+1)]).map(vs =&gt; [x,...vs]);
  // });
}
document.write(JSON.stringify(perms([1,2,3])));</code></pre>
</div>
</div>
</p>


blocks|key|3108473|text|这个问题的大多数答案使用昂贵的操作，如连续插入和删除数组中的项，或重复复制数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3108474|相反，这是典型的回溯解决方案：|3108475|function+permute(arr)+{
++var+results+=+[],
++++++l+=+arr.length,
++++++used+=+Array(l),+//+Array+of+bools.+Keeps+track+of+used+items
++++++data+=+Array(l);+//+Stores+items+of+the+current+permutation
++(function+backtracking(pos)+{
++++if(pos+==+l)+return+results.push(data.slice());
++++for(var+i=0;+i<l;+%2B%2Bi)+if(!used[i])+{+//+Iterate+unused+items
++++++used[i]+=+true;++++++//+Mark+item+as+used
++++++data[pos]+=+arr[i];++//+Assign+item+at+the+current+position
++++++backtracking(pos%2B1);+//+Recursive+call
++++++used[i]+=+false;+++++//+Mark+item+as+not+used
++++}
++})(0);
++return+results;
}|code-block|syntax|javascript|3108476|permute([1,2,3,4]);+//+[++[1,2,3,4],+[1,2,4,3],+/*+...+,+*/+[4,3,2,1]++]|3108477|由于结果数组很大，因此一个接一个地迭代结果可能是一个好主意，而不是同时分配所有数据。在ES6中，这可以通过生成器来完成：|3108478|function+permute(arr)+{
++var+l+=+arr.length,
++++++used+=+Array(l),
++++++data+=+Array(l);
++return+function*+backtracking(pos)+{
++++if(pos+==+l)+yield+data.slice();
++++else+for(var+i=0;+i<l;+%2B%2Bi)+if(!used[i])+{
++++++used[i]+=+true;
++++++data[pos]+=+arr[i];
++++++yield*+backtracking(pos%2B1);
++++++used[i]+=+false;
++++}
++}(0);
}|3108479|var+p+=+permute([1,2,3,4]);
p.next();+//+{value:+[1,2,3,4],+done:+false}
p.next();+//+{value:+[1,2,4,3],+done:+false}
//+...
p.next();+//+{value:+[4,3,2,1],+done:+false}
p.next();+//+{value:+undefined,+done:+true}|3108480|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|F|7|V|8|@]|9|@]|A|$G|H]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|X|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

<p>Most answers to this question use expensive operations like continuous insertions and deletions of items in an array, or copying arrays reiteratively.</p>

<p>Instead, this is the typical backtracking solution:</p>

<pre class="lang-js prettyprint-override"><code>function permute(arr) {
  var results = [],
      l = arr.length,
      used = Array(l), // Array of bools. Keeps track of used items
      data = Array(l); // Stores items of the current permutation
  (function backtracking(pos) {
    if(pos == l) return results.push(data.slice());
    for(var i=0; i&lt;l; ++i) if(!used[i]) { // Iterate unused items
      used[i] = true;      // Mark item as used
      data[pos] = arr[i];  // Assign item at the current position
      backtracking(pos+1); // Recursive call
      used[i] = false;     // Mark item as not used
    }
  })(0);
  return results;
}
</code></pre>

<pre class="lang-js prettyprint-override"><code>permute([1,2,3,4]); // [  [1,2,3,4], [1,2,4,3], /* ... , */ [4,3,2,1]  ]
</code></pre>

<p>Since the results array will be huge, it might be a good idea to iterate the results one by one instead of allocating all the data simultaneously. In ES6, this can be done with generators:</p>

<pre class="lang-js prettyprint-override"><code>function permute(arr) {
  var l = arr.length,
      used = Array(l),
      data = Array(l);
  return function* backtracking(pos) {
    if(pos == l) yield data.slice();
    else for(var i=0; i&lt;l; ++i) if(!used[i]) {
      used[i] = true;
      data[pos] = arr[i];
      yield* backtracking(pos+1);
      used[i] = false;
    }
  }(0);
}
</code></pre>

<pre class="lang-js prettyprint-override"><code>var p = permute([1,2,3,4]);
p.next(); // {value: [1,2,3,4], done: false}
p.next(); // {value: [1,2,4,3], done: false}
// ...
p.next(); // {value: [4,3,2,1], done: false}
p.next(); // {value: undefined, done: true}
</code></pre>


blocks|key|233176|text|function+nPr(xs,+r)+{
++++if+(!r)+return+[];
++++return+xs.reduce(function(memo,+cur,+i)+{
++++++++var+others++=+xs.slice(0,i).concat(xs.slice(i%2B1)),
++++++++++++perms+++=+nPr(others,+r-1),
++++++++++++newElms+=+!perms.length+?+[[cur]]+:
++++++++++++++++++++++perms.map(function(perm)+{+return+[cur].concat(perm)+});
++++++++return+memo.concat(newElms);
++++},+[]);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|233177|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function nPr(xs, r) {
    if (!r) return [];
    return xs.reduce(function(memo, cur, i) {
        var others  = xs.slice(0,i).concat(xs.slice(i+1)),
            perms   = nPr(others, r-1),
            newElms = !perms.length ? [[cur]] :
                      perms.map(function(perm) { return [cur].concat(perm) });
        return memo.concat(newElms);
    }, []);
}
</code></pre>


blocks|key|233179|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|233180|"use+strict";
function+getPermutations(arrP)+{
++++var+results+=+[];
++++var+arr+=+arrP;
++++arr.unshift(null);
++++var+length+=+arr.length;

++++while+(arr[0]+===+null)+{

++++++++results.push(arr.slice(1).join(''));

++++++++let+less+=+null;
++++++++let+lessIndex+=+null;

++++++++for+(let+i+=+length+-+1;+i+>+0;+i--)+{
++++++++++++if(arr[i+-+1]+<+arr[i]){
++++++++++++++++less+=+arr[i+-+1];
++++++++++++++++lessIndex+=+i+-+1;
++++++++++++++++break;
++++++++++++}
++++++++}

++++++++for+(let+i+=+length+-+1;+i+>+lessIndex;+i--)+{
++++++++++++if(arr[i]+>+less){
++++++++++++++++arr[lessIndex]+=+arr[i];
++++++++++++++++arr[i]+=+less;
++++++++++++++++break;
++++++++++++}
++++++++}

++++++++for(let+i+=+lessIndex+%2B+1;+i<length;+i%2B%2B){
+++++++++++for(let+j+=+i+%2B+1;+j+<+length;+j%2B%2B){
+++++++++++++++if(arr[i]+>+arr[j]+){
+++++++++++++++++++arr[i]+=+arr[i]+%2B+arr[j];
+++++++++++++++++++arr[j]+=+arr[i]+-+arr[j];
+++++++++++++++++++arr[i]+=+arr[i]+-+arr[j];
+++++++++++++++}
+++++++++++}
++++++++}
++++}

++++return+results;
}

var+res+=+getPermutations([1,2,3,4,5]);
var+out+=+document.getElementById('myTxtArr');
res.forEach(function(i){+out.value%2B=i%2B',+'});|code-block|syntax|javascript|233181|textarea{
+++height:500px;
++width:500px;
}|233182|<textarea+id='myTxtArr'></textarea>|233183|233184|输出按字典顺序排序的排列。仅适用于数字。在其他情况下，您必须更改第34行上的交换方法。|233185|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|I|3|J|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|K|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|U|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|O|$]]

<p><div class="snippet" data-lang="js" data-hide="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>"use strict";
function getPermutations(arrP) {
    var results = [];
    var arr = arrP;
    arr.unshift(null);
    var length = arr.length;

    while (arr[0] === null) {

        results.push(arr.slice(1).join(''));

        let less = null;
        let lessIndex = null;

        for (let i = length - 1; i &gt; 0; i--) {
            if(arr[i - 1] &lt; arr[i]){
                less = arr[i - 1];
                lessIndex = i - 1;
                break;
            }
        }

        for (let i = length - 1; i &gt; lessIndex; i--) {
            if(arr[i] &gt; less){
                arr[lessIndex] = arr[i];
                arr[i] = less;
                break;
            }
        }

        for(let i = lessIndex + 1; i&lt;length; i++){
           for(let j = i + 1; j &lt; length; j++){
               if(arr[i] &gt; arr[j] ){
                   arr[i] = arr[i] + arr[j];
                   arr[j] = arr[i] - arr[j];
                   arr[i] = arr[i] - arr[j];
               }
           }
        }
    }

    return results;
}

var res = getPermutations([1,2,3,4,5]);
var out = document.getElementById('myTxtArr');
res.forEach(function(i){ out.value+=i+', '});</code></pre>
<pre class="snippet-code-css lang-css prettyprint-override"><code>textarea{
   height:500px;
  width:500px;
}</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;textarea id='myTxtArr'&gt;&lt;/textarea&gt;</code></pre>
</div>
</div>
</p>

<p>Outputs lexicographically ordered permutations. Works only with numbers. In other case, you have to change the swap method on line 34.</p>


blocks|key|3108489|text|+++function+perm(xs)+{
+++++++return+xs.length+===+0+?+[[]]+:+perm(xs.slice(1)).reduce(function+(acc,+ys)+{
++++++++for+(var+i+=+0;+i+<+xs.length;+i%2B%2B)+{
++++++++++acc.push([].concat(ys.slice(0,+i),+xs[0],+ys.slice(i)));
++++++++}
++++++++return+acc;
++++++},+[]);
++++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3108490|使用以下命令进行测试：|unstyled|3108491|console.log(JSON.stringify(perm([1,+2,+3,4])));|3108492|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>   function perm(xs) {
       return xs.length === 0 ? [[]] : perm(xs.slice(1)).reduce(function (acc, ys) {
        for (var i = 0; i &lt; xs.length; i++) {
          acc.push([].concat(ys.slice(0, i), xs[0], ys.slice(i)));
        }
        return acc;
      }, []);
    }
</code></pre>

<p>Test it with:</p>

<pre><code>console.log(JSON.stringify(perm([1, 2, 3,4])));
</code></pre>


blocks|key|235736|text|以下非常有效的算法使用Heap's+method生成N个元素的所有排列，其运行时间复杂度为O(N!)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|235737|​|235738|function+permute(permutation)+{
++var+length+=+permutation.length,
++++++result+=+[permutation.slice()],
++++++c+=+new+Array(length).fill(0),
++++++i+=+1,+k,+p;

++while+(i+<+length)+{
++++if+(c[i]+<+i)+{
++++++k+=+i+%25+2+&&+c[i];
++++++p+=+permutation[i];
++++++permutation[i]+=+permutation[k];
++++++permutation[k]+=+p;
++++++%2B%2Bc[i];
++++++i+=+1;
++++++result.push(permutation.slice());
++++}+else+{
++++++c[i]+=+0;
++++++%2B%2Bi;
++++}
++}
++return+result;
}

console.log(permute([1,+2,+3]));|code-block|syntax|javascript|235739|235740|与实现为generator的算法相同，空间复杂度为O(N)：|235741|235742|function*+permute(permutation)+{
++var+length+=+permutation.length,
++++++c+=+Array(length).fill(0),
++++++i+=+1,+k,+p;

++yield+permutation.slice();
++while+(i+<+length)+{
++++if+(c[i]+<+i)+{
++++++k+=+i+%25+2+&&+c[i];
++++++p+=+permutation[i];
++++++permutation[i]+=+permutation[k];
++++++permutation[k]+=+p;
++++++%2B%2Bc[i];
++++++i+=+1;
++++++yield+permutation.slice();
++++}+else+{
++++++c[i]+=+0;
++++++%2B%2Bi;
++++}
++}
}

//+Memory+efficient+iteration+through+permutations:
for+(var+permutation+of+permute([1,+2,+3]))+console.log(permutation);

//+Simple+array+conversion:
var+permutations+=+[...permute([1,+2,+3])];|235743|235744|性能比较|235745|请随意将您的实现添加到以下benchmark.js测试套件中：|235746|235747|function+permute_SiGanteng(input)+{
++var+permArr+=+[],
++++usedChars+=+[];

++function+permute(input)+{
++++var+i,+ch;
++++for+(i+=+0;+i+<+input.length;+i%2B%2B)+{
++++++ch+=+input.splice(i,+1)[0];
++++++usedChars.push(ch);
++++++if+(input.length+==+0)+{
++++++++permArr.push(usedChars.slice());
++++++}
++++++permute(input);
++++++input.splice(i,+0,+ch);
++++++usedChars.pop();
++++}
++++return+permArr
++}
++return+permute(input);
}

function+permute_delimited(inputArr)+{
++var+results+=+[];

++function+permute(arr,+memo)+{
++++var+cur,+memo+=+memo+%7C%7C+[];
++++for+(var+i+=+0;+i+<+arr.length;+i%2B%2B)+{
++++++cur+=+arr.splice(i,+1);
++++++if+(arr.length+===+0)+{
++++++++results.push(memo.concat(cur));
++++++}
++++++permute(arr.slice(),+memo.concat(cur));
++++++arr.splice(i,+0,+cur[0]);
++++}
++++return+results;
++}
++return+permute(inputArr);
}

function+permute_monkey(inputArray)+{
++return+inputArray.reduce(function+permute(res,+item,+key,+arr)+{
++++return+res.concat(arr.length+>+1+&&+arr.slice(0,+key).concat(arr.slice(key+%2B+1)).reduce(permute,+[]).map(function(perm)+{
++++++return+[item].concat(perm);
++++})+%7C%7C+item);
++},+[]);
}

function+permute_Oriol(input)+{
++var+permArr+=+[],
++++usedChars+=+[];
++return+(function+main()+{
++++for+(var+i+=+0;+i+<+input.length;+i%2B%2B)+{
++++++var+ch+=+input.splice(i,+1)[0];
++++++usedChars.push(ch);
++++++if+(input.length+==+0)+{
++++++++permArr.push(usedChars.slice());
++++++}
++++++main();
++++++input.splice(i,+0,+ch);
++++++usedChars.pop();
++++}
++++return+permArr;
++})();
}

function+permute_MarkusT(input)+{
++function+permutate(array,+callback)+{
++++++function+p(array,+index,+callback)+{
++++++++++function+swap(a,+i1,+i2)+{
++++++++++++++var+t+=+a[i1];
++++++++++++++a[i1]+=+a[i2];
++++++++++++++a[i2]+=+t;
++++++++++}
++++++++++if+(index+==+array.length+-+1)+{
++++++++++++++callback(array);
++++++++++++++return+1;
++++++++++}+else+{
++++++++++++++var+count+=+p(array,+index+%2B+1,+callback);
++++++++++++++for+(var+i+=+index+%2B+1;+i+<+array.length;+i%2B%2B)+{
++++++++++++++++++swap(array,+i,+index);
++++++++++++++++++count+%2B=+p(array,+index+%2B+1,+callback);
++++++++++++++++++swap(array,+i,+index);
++++++++++++++}
++++++++++++++return+count;
++++++++++}
++++++}
++++++if+(!array+%7C%7C+array.length+==+0)+{
++++++++++return+0;
++++++}
++++++return+p(array,+0,+callback);
++}
++var+result+=+[];
++permutate(input,+function(a)+{
++++++result.push(a.slice(0));
++});
++return+result;
}

function+permute_le_m(permutation)+{
++var+length+=+permutation.length,
++		result+=+[permutation.slice()],
++++++c+=+new+Array(length).fill(0),
++++++i+=+1,+k,+p;
++
++while+(i+<+length)+{
++++if+(c[i]+<+i)+{
++++++k+=+i+%25+2+&&+c[i],
++++++p+=+permutation[i];
++++++permutation[i]+=+permutation[k];
++++++permutation[k]+=+p;
++++++%2B%2Bc[i];
++++++i+=+1;
++++++result.push(permutation.slice());
++++}+else+{
++++++c[i]+=+0;
++++++%2B%2Bi;
++++}
++}
++return+result;
}

function+permute_Urielzen(arr)+{
++++var+finalArr+=+[];
++++var+iterator+=+function+(arrayTaken,+tree)+{
++++++++for+(var+i+=+0;+i+<+tree;+i%2B%2B)+{
++++++++++++var+temp+=+arrayTaken.slice();
++++++++++++temp.splice(tree+-+1+-+i,+0,+temp.splice(tree+-+1,+1)[0]);
++++++++++++if+(tree+>=+arr.length)+{
++++++++++++++++finalArr.push(temp);
++++++++++++}+else+{+iterator(temp,+tree+%2B+1);+}
++++++++}
++++}
++++iterator(arr,+1);+return+finalArr;
}

function+permute_Taylor_Hakes(arr)+{
++var+permutations+=+[];
++if+(arr.length+===+1)+{
++++return+[+arr+];
++}

++for+(var+i+=+0;+i+<++arr.length;+i%2B%2B)+{+
++++var+subPerms+=+permute_Taylor_Hakes(arr.slice(0,+i).concat(arr.slice(i+%2B+1)));
++++for+(var+j+=+0;+j+<+subPerms.length;+j%2B%2B)+{
++++++subPerms[j].unshift(arr[i]);
++++++permutations.push(subPerms[j]);
++++}
++}
++return+permutations;
}

var+Combinatorics+=+(function+()+{
++++'use+strict';
++++var+version+=+"0.5.2";
++++/*+combinatory+arithmetics+*/
++++var+P+=+function(m,+n)+{
++++++++var+p+=+1;
++++++++while+(n--)+p+*=+m--;
++++++++return+p;
++++};
++++var+C+=+function(m,+n)+{
++++++++if+(n+>+m)+{
++++++++++++return+0;
++++++++}
++++++++return+P(m,+n)+/+P(n,+n);
++++};
++++var+factorial+=+function(n)+{
++++++++return+P(n,+n);
++++};
++++var+factoradic+=+function(n,+d)+{
++++++++var+f+=+1;
++++++++if+(!d)+{
++++++++++++for+(d+=+1;+f+<+n;+f+*=+%2B%2Bd);
++++++++++++if+(f+>+n)+f+/=+d--;
++++++++}+else+{
++++++++++++f+=+factorial(d);
++++++++}
++++++++var+result+=+[0];
++++++++for+(;+d;+f+/=+d--)+{
++++++++++++result[d]+=+Math.floor(n+/+f);
++++++++++++n+%25=+f;
++++++++}
++++++++return+result;
++++};
++++/*+common+methods+*/
++++var+addProperties+=+function(dst,+src)+{
++++++++Object.keys(src).forEach(function(p)+{
++++++++++++Object.defineProperty(dst,+p,+{
++++++++++++++++value:+src[p],
++++++++++++++++configurable:+p+==+'next'
++++++++++++});
++++++++});
++++};
++++var+hideProperty+=+function(o,+p)+{
++++++++Object.defineProperty(o,+p,+{
++++++++++++writable:+true
++++++++});
++++};
++++var+toArray+=+function(f)+{
++++++++var+e,+result+=+[];
++++++++this.init();
++++++++while+(e+=+this.next())+result.push(f+?+f(e)+:+e);
++++++++this.init();
++++++++return+result;
++++};
++++var+common+=+{
++++++++toArray:+toArray,
++++++++map:+toArray,
++++++++forEach:+function(f)+{
++++++++++++var+e;
++++++++++++this.init();
++++++++++++while+(e+=+this.next())+f(e);
++++++++++++this.init();
++++++++},
++++++++filter:+function(f)+{
++++++++++++var+e,+result+=+[];
++++++++++++this.init();
++++++++++++while+(e+=+this.next())+if+(f(e))+result.push(e);
++++++++++++this.init();
++++++++++++return+result;
++++++++},
++++++++lazyMap:+function(f)+{
++++++++++++this._lazyMap+=+f;
++++++++++++return+this;
++++++++},
++++++++lazyFilter:+function(f)+{
++++++++++++Object.defineProperty(this,+'next',+{
++++++++++++++++writable:+true
++++++++++++});
++++++++++++if+(typeof+f+!==+'function')+{
++++++++++++++++this.next+=+this._next;
++++++++++++}+else+{
++++++++++++++++if+(typeof+(this._next)+!==+'function')+{
++++++++++++++++++++this._next+=+this.next;
++++++++++++++++}
++++++++++++++++var+_next+=+this._next.bind(this);
++++++++++++++++this.next+=+(function()+{
++++++++++++++++++++var+e;
++++++++++++++++++++while+(e+=+_next())+{
++++++++++++++++++++++++if+(f(e))
++++++++++++++++++++++++++++return+e;
++++++++++++++++++++}
++++++++++++++++++++return+e;
++++++++++++++++}).bind(this);
++++++++++++}
++++++++++++Object.defineProperty(this,+'next',+{
++++++++++++++++writable:+false
++++++++++++});
++++++++++++return+this;
++++++++}

++++};
++++/*+power+set+*/
++++var+power+=+function(ary,+fun)+{
++++++++var+size+=+1+<<+ary.length,
++++++++++++sizeOf+=+function()+{
++++++++++++++++return+size;
++++++++++++},
++++++++++++that+=+Object.create(ary.slice(),+{
++++++++++++++++length:+{
++++++++++++++++++++get:+sizeOf
++++++++++++++++}
++++++++++++});
++++++++hideProperty(that,+'index');
++++++++addProperties(that,+{
++++++++++++valueOf:+sizeOf,
++++++++++++init:+function()+{
++++++++++++++++that.index+=+0;
++++++++++++},
++++++++++++nth:+function(n)+{
++++++++++++++++if+(n+>=+size)+return;
++++++++++++++++var+i+=+0,
++++++++++++++++++++result+=+[];
++++++++++++++++for+(;+n;+n+>>>=+1,+i%2B%2B)+if+(n+&+1)+result.push(this[i]);
++++++++++++++++return+(typeof+(that._lazyMap)+===+'function')?that._lazyMap(result):result;
++++++++++++},
++++++++++++next:+function()+{
++++++++++++++++return+this.nth(this.index%2B%2B);
++++++++++++}
++++++++});
++++++++addProperties(that,+common);
++++++++that.init();
++++++++return+(typeof+(fun)+===+'function')+?+that.map(fun)+:+that;
++++};
++++/*+combination+*/
++++var+nextIndex+=+function(n)+{
++++++++var+smallest+=+n+&+-n,
++++++++++++ripple+=+n+%2B+smallest,
++++++++++++new_smallest+=+ripple+&+-ripple,
++++++++++++ones+=+((new_smallest+/+smallest)+>>+1)+-+1;
++++++++return+ripple+%7C+ones;
++++};
++++var+combination+=+function(ary,+nelem,+fun)+{
++++++++if+(!nelem)+nelem+=+ary.length;
++++++++if+(nelem+<+1)+throw+new+RangeError;
++++++++if+(nelem+>+ary.length)+throw+new+RangeError;
++++++++var+first+=+(1+<<+nelem)+-+1,
++++++++++++size+=+C(ary.length,+nelem),
++++++++++++maxIndex+=+1+<<+ary.length,
++++++++++++sizeOf+=+function()+{
++++++++++++++++return+size;
++++++++++++},
++++++++++++that+=+Object.create(ary.slice(),+{
++++++++++++++++length:+{
++++++++++++++++++++get:+sizeOf
++++++++++++++++}
++++++++++++});
++++++++hideProperty(that,+'index');
++++++++addProperties(that,+{
++++++++++++valueOf:+sizeOf,
++++++++++++init:+function()+{
++++++++++++++++this.index+=+first;
++++++++++++},
++++++++++++next:+function()+{
++++++++++++++++if+(this.index+>=+maxIndex)+return;
++++++++++++++++var+i+=+0,
++++++++++++++++++++n+=+this.index,
++++++++++++++++++++result+=+[];
++++++++++++++++for+(;+n;+n+>>>=+1,+i%2B%2B)+{
++++++++++++++++++++if+(n+&+1)+result[result.length]+=+this[i];
++++++++++++++++}

++++++++++++++++this.index+=+nextIndex(this.index);
++++++++++++++++return+(typeof+(that._lazyMap)+===+'function')?that._lazyMap(result):result;
++++++++++++}
++++++++});
++++++++addProperties(that,+common);
++++++++that.init();
++++++++return+(typeof+(fun)+===+'function')+?+that.map(fun)+:+that;
++++};
++++/*+permutation+*/
++++var+_permutation+=+function(ary)+{
++++++++var+that+=+ary.slice(),
++++++++++++size+=+factorial(that.length);
++++++++that.index+=+0;
++++++++that.next+=+function()+{
++++++++++++if+(this.index+>=+size)+return;
++++++++++++var+copy+=+this.slice(),
++++++++++++++++digits+=+factoradic(this.index,+this.length),
++++++++++++++++result+=+[],
++++++++++++++++i+=+this.length+-+1;
++++++++++++for+(;+i+>=+0;+--i)+result.push(copy.splice(digits[i],+1)[0]);
++++++++++++this.index%2B%2B;
++++++++++++return+(typeof+(that._lazyMap)+===+'function')?that._lazyMap(result):result;
++++++++};
++++++++return+that;
++++};
++++//+which+is+really+a+permutation+of+combination
++++var+permutation+=+function(ary,+nelem,+fun)+{
++++++++if+(!nelem)+nelem+=+ary.length;
++++++++if+(nelem+<+1)+throw+new+RangeError;
++++++++if+(nelem+>+ary.length)+throw+new+RangeError;
++++++++var+size+=+P(ary.length,+nelem),
++++++++++++sizeOf+=+function()+{
++++++++++++++++return+size;
++++++++++++},
++++++++++++that+=+Object.create(ary.slice(),+{
++++++++++++++++length:+{
++++++++++++++++++++get:+sizeOf
++++++++++++++++}
++++++++++++});
++++++++hideProperty(that,+'cmb');
++++++++hideProperty(that,+'per');
++++++++addProperties(that,+{
++++++++++++valueOf:+function()+{
++++++++++++++++return+size;
++++++++++++},
++++++++++++init:+function()+{
++++++++++++++++this.cmb+=+combination(ary,+nelem);
++++++++++++++++this.per+=+_permutation(this.cmb.next());
++++++++++++},
++++++++++++next:+function()+{
++++++++++++++++var+result+=+this.per.next();
++++++++++++++++if+(!result)+{
++++++++++++++++++++var+cmb+=+this.cmb.next();
++++++++++++++++++++if+(!cmb)+return;
++++++++++++++++++++this.per+=+_permutation(cmb);
++++++++++++++++++++return+this.next();
++++++++++++++++}
++++++++++++++++return+(typeof+(that._lazyMap)+===+'function')?that._lazyMap(result):result;
++++++++++++}
++++++++});
++++++++addProperties(that,+common);
++++++++that.init();
++++++++return+(typeof+(fun)+===+'function')+?+that.map(fun)+:+that;
++++};

++++/*+export+*/
++++var+Combinatorics+=+Object.create(null);
++++addProperties(Combinatorics,+{
++++++++C:+C,
++++++++P:+P,
++++++++factorial:+factorial,
++++++++factoradic:+factoradic,
++++++++permutation:+permutation,
++++});
++++return+Combinatorics;
})();

function+permute_Technicalbloke(inputArray)+{
++if+(inputArray.length+===+1)+return+inputArray;
++return+inputArray.reduce(+function(accumulator,_,index){
++++permute_Technicalbloke([...inputArray.slice(0,index),...inputArray.slice(index%2B1)])
++++.map(value=>accumulator.push([inputArray[index],value]));
++++return+accumulator;
++},[]);
}

var+suite+=+new+Benchmark.Suite;
var+input+=+[0,+1,+2,+3,+4];

suite.add('permute_SiGanteng',+function()+{
++++permute_SiGanteng(input);
++})
++.add('permute_delimited',+function()+{
++++permute_delimited(input);
++})
++.add('permute_monkey',+function()+{
++++permute_monkey(input);
++})
++.add('permute_Oriol',+function()+{
++++permute_Oriol(input);
++})
++.add('permute_MarkusT',+function()+{
++++permute_MarkusT(input);
++})
++.add('permute_le_m',+function()+{
++++permute_le_m(input);
++})
++.add('permute_Urielzen',+function()+{
++++permute_Urielzen(input);
++})
++.add('permute_Taylor_Hakes',+function()+{
++++permute_Taylor_Hakes(input);
++})
++.add('permute_Combinatorics',+function()+{
++++Combinatorics.permutation(input).toArray();
++})
++.add('permute_Technicalbloke',+function()+{
++++permute_Technicalbloke(input);
++})
++.on('cycle',+function(event)+{
++++console.log(String(event.target));
++})
++.on('complete',+function()+{
++++console.log('Fastest+is+'+%2B+this.filter('fastest').map('name'));
++})
++.run({async:+true});|235748|<script+src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>
<script+src="https://cdnjs.cloudflare.com/ajax/libs/platform/1.3.4/platform.min.js"></script>
<script+src="https://cdnjs.cloudflare.com/ajax/libs/benchmark/2.1.4/benchmark.min.js"></script>|235749|235750|Chrome+48的运行时结果：|235751|此algorithm|235752| 153.115ms+MarkusT|unordered-list-item|235753|
|235754| 401.255ms+js-combinatorics|235755|235756| 497.037ms+Urielzen|235757|235758| 925.669ms+Oriol|235759|235760|1026.571ms+SiGanteng|235761|235762|2529.841ms+delimited|235763|235764|3992.622ms+monkey|235765|235766|4514.665ms+Oriol|235767|
的|235768|  99.152ms|235769|235770|entityMap|0|LINK|mutability|MUTABLE|url|http://homepage.math.uiowa.edu/~goodman/22m150.dir/2007/Permutation%2520Generation%2520Methods.pdf|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*|2|https://benchmarkjs.com/|3|https://stackoverflow.com/a/11629015/1647737|4|https://stackoverflow.com/a/30013816/1647737|5|https://stackoverflow.com/a/24622772/1647737|6|https://stackoverflow.com/a/11509565/1647737|7|https://stackoverflow.com/a/9960925/1647737|8|https://stackoverflow.com/a/20871714/1647737|9|https://stackoverflow.com/a/22063440/1647737|10|https://stackoverflow.com/a/32551801/1647737^0|B|D|0|0|0|0|0|4|9|1|0|0|0|0|0|D|C|2|0|0|0|0|0|0|0|B|7|3|0|0|B|G|4|0|0|B|8|5|0|0|B|5|6|0|0|B|9|7|0|0|B|9|8|0|0|B|6|9|0|0|B|5|A|0|0|0|0^^$0|@$1|2|3|4|5|6|7|2R|8|@]|9|@$A|2S|B|2T|1|2U]]|C|$]]|$1|D|3|E|5|6|7|2V|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|2W|8|@]|9|@]|C|$I|J]]|$1|K|3|E|5|6|7|2X|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|2Y|8|@]|9|@$A|2Z|B|30|1|31]]|C|$]]|$1|N|3|E|5|6|7|32|8|@]|9|@]|C|$]]|$1|O|3|P|5|H|7|33|8|@]|9|@]|C|$I|J]]|$1|Q|3|E|5|6|7|34|8|@]|9|@]|C|$]]|$1|R|3|S|5|6|7|35|8|@]|9|@]|C|$]]|$1|T|3|U|5|6|7|36|8|@]|9|@$A|37|B|38|1|39]]|C|$]]|$1|V|3|E|5|6|7|3A|8|@]|9|@]|C|$]]|$1|W|3|X|5|H|7|3B|8|@]|9|@]|C|$I|J]]|$1|Y|3|Z|5|H|7|3C|8|@]|9|@]|C|$I|J]]|$1|10|3|E|5|6|7|3D|8|@]|9|@]|C|$]]|$1|11|3|12|5|6|7|3E|8|@]|9|@]|C|$]]|$1|13|3|14|5|6|7|3F|8|@]|9|@]|C|$]]|$1|15|3|16|5|17|7|3G|8|@]|9|@$A|3H|B|3I|1|3J]]|C|$]]|$1|18|3|19|5|6|7|3K|8|@]|9|@]|C|$]]|$1|1A|3|1B|5|17|7|3L|8|@]|9|@$A|3M|B|3N|1|3O]]|C|$]]|$1|1C|3|19|5|6|7|3P|8|@]|9|@]|C|$]]|$1|1D|3|1E|5|17|7|3Q|8|@]|9|@$A|3R|B|3S|1|3T]]|C|$]]|$1|1F|3|19|5|6|7|3U|8|@]|9|@]|C|$]]|$1|1G|3|1H|5|17|7|3V|8|@]|9|@$A|3W|B|3X|1|3Y]]|C|$]]|$1|1I|3|19|5|6|7|3Z|8|@]|9|@]|C|$]]|$1|1J|3|1K|5|17|7|40|8|@]|9|@$A|41|B|42|1|43]]|C|$]]|$1|1L|3|19|5|6|7|44|8|@]|9|@]|C|$]]|$1|1M|3|1N|5|17|7|45|8|@]|9|@$A|46|B|47|1|48]]|C|$]]|$1|1O|3|19|5|6|7|49|8|@]|9|@]|C|$]]|$1|1P|3|1Q|5|17|7|4A|8|@]|9|@$A|4B|B|4C|1|4D]]|C|$]]|$1|1R|3|19|5|6|7|4E|8|@]|9|@]|C|$]]|$1|1S|3|1T|5|17|7|4F|8|@]|9|@$A|4G|B|4H|1|4I]]|C|$]]|$1|1U|3|1V|5|6|7|4J|8|@]|9|@]|C|$]]|$1|1W|3|1X|5|17|7|4K|8|@]|9|@]|C|$]]|$1|1Y|3|-4|5|6|7|4L|8|@]|9|@]|C|$]]|$1|1Z|3|-4|5|6|7|4M|8|@]|9|@]|C|$]]]|20|$21|$5|22|23|24|C|$25|26]]|27|$5|22|23|24|C|$25|28]]|29|$5|22|23|24|C|$25|2A]]|2B|$5|22|23|24|C|$25|2C]]|2D|$5|22|23|24|C|$25|2E]]|2F|$5|22|23|24|C|$25|2G]]|2H|$5|22|23|24|C|$25|2I]]|2J|$5|22|23|24|C|$25|2K]]|2L|$5|22|23|24|C|$25|2M]]|2N|$5|22|23|24|C|$25|2O]]|2P|$5|22|23|24|C|$25|2Q]]]]

<p>The following very efficient algorithm uses <a href="http://homepage.math.uiowa.edu/~goodman/22m150.dir/2007/Permutation%20Generation%20Methods.pdf" rel="noreferrer">Heap's method</a> to generate all permutations of N elements with runtime complexity in O(N!):</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function permute(permutation) {
  var length = permutation.length,
      result = [permutation.slice()],
      c = new Array(length).fill(0),
      i = 1, k, p;

  while (i &lt; length) {
    if (c[i] &lt; i) {
      k = i % 2 &amp;&amp; c[i];
      p = permutation[i];
      permutation[i] = permutation[k];
      permutation[k] = p;
      ++c[i];
      i = 1;
      result.push(permutation.slice());
    } else {
      c[i] = 0;
      ++i;
    }
  }
  return result;
}

console.log(permute([1, 2, 3]));</code></pre>
</div>
</div>
</p>

<p>The same algorithm implemented as a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*" rel="noreferrer">generator</a> with space complexity in O(N):</p>

<p><div class="snippet" data-lang="js" data-hide="true" data-console="true" data-babel="false">
<div class="snippet-code snippet-currently-hidden">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function* permute(permutation) {
  var length = permutation.length,
      c = Array(length).fill(0),
      i = 1, k, p;

  yield permutation.slice();
  while (i &lt; length) {
    if (c[i] &lt; i) {
      k = i % 2 &amp;&amp; c[i];
      p = permutation[i];
      permutation[i] = permutation[k];
      permutation[k] = p;
      ++c[i];
      i = 1;
      yield permutation.slice();
    } else {
      c[i] = 0;
      ++i;
    }
  }
}

// Memory efficient iteration through permutations:
for (var permutation of permute([1, 2, 3])) console.log(permutation);

// Simple array conversion:
var permutations = [...permute([1, 2, 3])];</code></pre>
</div>
</div>
</p>

<h3>Performance comparison</h3>

<p>Feel free to add your implementation to the following <a href="https://benchmarkjs.com/" rel="noreferrer">benchmark.js</a> test suite:</p>

<p><div class="snippet" data-lang="js" data-hide="true" data-console="true" data-babel="false">
<div class="snippet-code snippet-currently-hidden">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function permute_SiGanteng(input) {
  var permArr = [],
    usedChars = [];

  function permute(input) {
    var i, ch;
    for (i = 0; i &lt; input.length; i++) {
      ch = input.splice(i, 1)[0];
      usedChars.push(ch);
      if (input.length == 0) {
        permArr.push(usedChars.slice());
      }
      permute(input);
      input.splice(i, 0, ch);
      usedChars.pop();
    }
    return permArr
  }
  return permute(input);
}

function permute_delimited(inputArr) {
  var results = [];

  function permute(arr, memo) {
    var cur, memo = memo || [];
    for (var i = 0; i &lt; arr.length; i++) {
      cur = arr.splice(i, 1);
      if (arr.length === 0) {
        results.push(memo.concat(cur));
      }
      permute(arr.slice(), memo.concat(cur));
      arr.splice(i, 0, cur[0]);
    }
    return results;
  }
  return permute(inputArr);
}

function permute_monkey(inputArray) {
  return inputArray.reduce(function permute(res, item, key, arr) {
    return res.concat(arr.length &gt; 1 &amp;&amp; arr.slice(0, key).concat(arr.slice(key + 1)).reduce(permute, []).map(function(perm) {
      return [item].concat(perm);
    }) || item);
  }, []);
}

function permute_Oriol(input) {
  var permArr = [],
    usedChars = [];
  return (function main() {
    for (var i = 0; i &lt; input.length; i++) {
      var ch = input.splice(i, 1)[0];
      usedChars.push(ch);
      if (input.length == 0) {
        permArr.push(usedChars.slice());
      }
      main();
      input.splice(i, 0, ch);
      usedChars.pop();
    }
    return permArr;
  })();
}

function permute_MarkusT(input) {
  function permutate(array, callback) {
      function p(array, index, callback) {
          function swap(a, i1, i2) {
              var t = a[i1];
              a[i1] = a[i2];
              a[i2] = t;
          }
          if (index == array.length - 1) {
              callback(array);
              return 1;
          } else {
              var count = p(array, index + 1, callback);
              for (var i = index + 1; i &lt; array.length; i++) {
                  swap(array, i, index);
                  count += p(array, index + 1, callback);
                  swap(array, i, index);
              }
              return count;
          }
      }
      if (!array || array.length == 0) {
          return 0;
      }
      return p(array, 0, callback);
  }
  var result = [];
  permutate(input, function(a) {
      result.push(a.slice(0));
  });
  return result;
}

function permute_le_m(permutation) {
  var length = permutation.length,
  		result = [permutation.slice()],
      c = new Array(length).fill(0),
      i = 1, k, p;
  
  while (i &lt; length) {
    if (c[i] &lt; i) {
      k = i % 2 &amp;&amp; c[i],
      p = permutation[i];
      permutation[i] = permutation[k];
      permutation[k] = p;
      ++c[i];
      i = 1;
      result.push(permutation.slice());
    } else {
      c[i] = 0;
      ++i;
    }
  }
  return result;
}

function permute_Urielzen(arr) {
    var finalArr = [];
    var iterator = function (arrayTaken, tree) {
        for (var i = 0; i &lt; tree; i++) {
            var temp = arrayTaken.slice();
            temp.splice(tree - 1 - i, 0, temp.splice(tree - 1, 1)[0]);
            if (tree &gt;= arr.length) {
                finalArr.push(temp);
            } else { iterator(temp, tree + 1); }
        }
    }
    iterator(arr, 1); return finalArr;
}

function permute_Taylor_Hakes(arr) {
  var permutations = [];
  if (arr.length === 1) {
    return [ arr ];
  }

  for (var i = 0; i &lt;  arr.length; i++) { 
    var subPerms = permute_Taylor_Hakes(arr.slice(0, i).concat(arr.slice(i + 1)));
    for (var j = 0; j &lt; subPerms.length; j++) {
      subPerms[j].unshift(arr[i]);
      permutations.push(subPerms[j]);
    }
  }
  return permutations;
}

var Combinatorics = (function () {
    'use strict';
    var version = "0.5.2";
    /* combinatory arithmetics */
    var P = function(m, n) {
        var p = 1;
        while (n--) p *= m--;
        return p;
    };
    var C = function(m, n) {
        if (n &gt; m) {
            return 0;
        }
        return P(m, n) / P(n, n);
    };
    var factorial = function(n) {
        return P(n, n);
    };
    var factoradic = function(n, d) {
        var f = 1;
        if (!d) {
            for (d = 1; f &lt; n; f *= ++d);
            if (f &gt; n) f /= d--;
        } else {
            f = factorial(d);
        }
        var result = [0];
        for (; d; f /= d--) {
            result[d] = Math.floor(n / f);
            n %= f;
        }
        return result;
    };
    /* common methods */
    var addProperties = function(dst, src) {
        Object.keys(src).forEach(function(p) {
            Object.defineProperty(dst, p, {
                value: src[p],
                configurable: p == 'next'
            });
        });
    };
    var hideProperty = function(o, p) {
        Object.defineProperty(o, p, {
            writable: true
        });
    };
    var toArray = function(f) {
        var e, result = [];
        this.init();
        while (e = this.next()) result.push(f ? f(e) : e);
        this.init();
        return result;
    };
    var common = {
        toArray: toArray,
        map: toArray,
        forEach: function(f) {
            var e;
            this.init();
            while (e = this.next()) f(e);
            this.init();
        },
        filter: function(f) {
            var e, result = [];
            this.init();
            while (e = this.next()) if (f(e)) result.push(e);
            this.init();
            return result;
        },
        lazyMap: function(f) {
            this._lazyMap = f;
            return this;
        },
        lazyFilter: function(f) {
            Object.defineProperty(this, 'next', {
                writable: true
            });
            if (typeof f !== 'function') {
                this.next = this._next;
            } else {
                if (typeof (this._next) !== 'function') {
                    this._next = this.next;
                }
                var _next = this._next.bind(this);
                this.next = (function() {
                    var e;
                    while (e = _next()) {
                        if (f(e))
                            return e;
                    }
                    return e;
                }).bind(this);
            }
            Object.defineProperty(this, 'next', {
                writable: false
            });
            return this;
        }

    };
    /* power set */
    var power = function(ary, fun) {
        var size = 1 &lt;&lt; ary.length,
            sizeOf = function() {
                return size;
            },
            that = Object.create(ary.slice(), {
                length: {
                    get: sizeOf
                }
            });
        hideProperty(that, 'index');
        addProperties(that, {
            valueOf: sizeOf,
            init: function() {
                that.index = 0;
            },
            nth: function(n) {
                if (n &gt;= size) return;
                var i = 0,
                    result = [];
                for (; n; n &gt;&gt;&gt;= 1, i++) if (n &amp; 1) result.push(this[i]);
                return (typeof (that._lazyMap) === 'function')?that._lazyMap(result):result;
            },
            next: function() {
                return this.nth(this.index++);
            }
        });
        addProperties(that, common);
        that.init();
        return (typeof (fun) === 'function') ? that.map(fun) : that;
    };
    /* combination */
    var nextIndex = function(n) {
        var smallest = n &amp; -n,
            ripple = n + smallest,
            new_smallest = ripple &amp; -ripple,
            ones = ((new_smallest / smallest) &gt;&gt; 1) - 1;
        return ripple | ones;
    };
    var combination = function(ary, nelem, fun) {
        if (!nelem) nelem = ary.length;
        if (nelem &lt; 1) throw new RangeError;
        if (nelem &gt; ary.length) throw new RangeError;
        var first = (1 &lt;&lt; nelem) - 1,
            size = C(ary.length, nelem),
            maxIndex = 1 &lt;&lt; ary.length,
            sizeOf = function() {
                return size;
            },
            that = Object.create(ary.slice(), {
                length: {
                    get: sizeOf
                }
            });
        hideProperty(that, 'index');
        addProperties(that, {
            valueOf: sizeOf,
            init: function() {
                this.index = first;
            },
            next: function() {
                if (this.index &gt;= maxIndex) return;
                var i = 0,
                    n = this.index,
                    result = [];
                for (; n; n &gt;&gt;&gt;= 1, i++) {
                    if (n &amp; 1) result[result.length] = this[i];
                }

                this.index = nextIndex(this.index);
                return (typeof (that._lazyMap) === 'function')?that._lazyMap(result):result;
            }
        });
        addProperties(that, common);
        that.init();
        return (typeof (fun) === 'function') ? that.map(fun) : that;
    };
    /* permutation */
    var _permutation = function(ary) {
        var that = ary.slice(),
            size = factorial(that.length);
        that.index = 0;
        that.next = function() {
            if (this.index &gt;= size) return;
            var copy = this.slice(),
                digits = factoradic(this.index, this.length),
                result = [],
                i = this.length - 1;
            for (; i &gt;= 0; --i) result.push(copy.splice(digits[i], 1)[0]);
            this.index++;
            return (typeof (that._lazyMap) === 'function')?that._lazyMap(result):result;
        };
        return that;
    };
    // which is really a permutation of combination
    var permutation = function(ary, nelem, fun) {
        if (!nelem) nelem = ary.length;
        if (nelem &lt; 1) throw new RangeError;
        if (nelem &gt; ary.length) throw new RangeError;
        var size = P(ary.length, nelem),
            sizeOf = function() {
                return size;
            },
            that = Object.create(ary.slice(), {
                length: {
                    get: sizeOf
                }
            });
        hideProperty(that, 'cmb');
        hideProperty(that, 'per');
        addProperties(that, {
            valueOf: function() {
                return size;
            },
            init: function() {
                this.cmb = combination(ary, nelem);
                this.per = _permutation(this.cmb.next());
            },
            next: function() {
                var result = this.per.next();
                if (!result) {
                    var cmb = this.cmb.next();
                    if (!cmb) return;
                    this.per = _permutation(cmb);
                    return this.next();
                }
                return (typeof (that._lazyMap) === 'function')?that._lazyMap(result):result;
            }
        });
        addProperties(that, common);
        that.init();
        return (typeof (fun) === 'function') ? that.map(fun) : that;
    };

    /* export */
    var Combinatorics = Object.create(null);
    addProperties(Combinatorics, {
        C: C,
        P: P,
        factorial: factorial,
        factoradic: factoradic,
        permutation: permutation,
    });
    return Combinatorics;
})();

function permute_Technicalbloke(inputArray) {
  if (inputArray.length === 1) return inputArray;
  return inputArray.reduce( function(accumulator,_,index){
    permute_Technicalbloke([...inputArray.slice(0,index),...inputArray.slice(index+1)])
    .map(value=&gt;accumulator.push([inputArray[index],value]));
    return accumulator;
  },[]);
}

var suite = new Benchmark.Suite;
var input = [0, 1, 2, 3, 4];

suite.add('permute_SiGanteng', function() {
    permute_SiGanteng(input);
  })
  .add('permute_delimited', function() {
    permute_delimited(input);
  })
  .add('permute_monkey', function() {
    permute_monkey(input);
  })
  .add('permute_Oriol', function() {
    permute_Oriol(input);
  })
  .add('permute_MarkusT', function() {
    permute_MarkusT(input);
  })
  .add('permute_le_m', function() {
    permute_le_m(input);
  })
  .add('permute_Urielzen', function() {
    permute_Urielzen(input);
  })
  .add('permute_Taylor_Hakes', function() {
    permute_Taylor_Hakes(input);
  })
  .add('permute_Combinatorics', function() {
    Combinatorics.permutation(input).toArray();
  })
  .add('permute_Technicalbloke', function() {
    permute_Technicalbloke(input);
  })
  .on('cycle', function(event) {
    console.log(String(event.target));
  })
  .on('complete', function() {
    console.log('Fastest is ' + this.filter('fastest').map('name'));
  })
  .run({async: true});</code></pre>
<pre class="snippet-code-html lang-html prettyprint-override"><code>&lt;script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"&gt;&lt;/script&gt;
&lt;script src="https://cdnjs.cloudflare.com/ajax/libs/platform/1.3.4/platform.min.js"&gt;&lt;/script&gt;
&lt;script src="https://cdnjs.cloudflare.com/ajax/libs/benchmark/2.1.4/benchmark.min.js"&gt;&lt;/script&gt;</code></pre>
</div>
</div>
</p>

<p>Run-time results for Chrome 48:</p>

<ul>
<li>  99.152ms <strong>This algorithm</strong></li>
<li> 153.115ms <a href="https://stackoverflow.com/a/11629015/1647737">MarkusT</a></li>
<li> 401.255ms <a href="https://stackoverflow.com/a/30013816/1647737">js-combinatorics</a></li>
<li> 497.037ms <a href="https://stackoverflow.com/a/24622772/1647737">Urielzen</a></li>
<li> 925.669ms <a href="https://stackoverflow.com/a/11509565/1647737">Oriol</a></li>
<li>1026.571ms <a href="https://stackoverflow.com/a/9960925/1647737">SiGanteng</a></li>
<li>2529.841ms <a href="https://stackoverflow.com/a/20871714/1647737">delimited</a></li>
<li>3992.622ms <a href="https://stackoverflow.com/a/22063440/1647737">monkey</a></li>
<li>4514.665ms <a href="https://stackoverflow.com/a/32551801/1647737">Oriol</a></li>
</ul>


blocks|key|3108547|text|function+swap(array1,+index1,+index2)+{
++++var+temp;
++++temp+=+array1[index1];
++++array1[index1]+=+array1[index2];
++++array1[index2]+=+temp;
}

function+permute(a,+l,+r)+{
++++var+i;
++++if+(l+==+r)+{
++++++++console.log(a.join(''));
++++}+else+{
++++++++for+(i+=+l;+i+<=+r;+i%2B%2B)+{
++++++++++++swap(a,+l,+i);
++++++++++++permute(a,+l+%2B+1,+r);
++++++++++++swap(a,+l,+i);
++++++++}
++++}
}


permute(["A","B","C",+"D"],0,3);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3108548|//示例执行//有关更多详细信息，请参阅此链接|unstyled|3108549|//+http://www.geeksforgeeks.org/write-a-c-program-to-print-all-permutations-of-a-given-string/|offset|length|3108550|entityMap|0|LINK|mutability|MUTABLE|url|http://www.geeksforgeeks.org/write-a-c-program-to-print-all-permutations-of-a-given-string/^0|0|0|3|2J|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|F|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<pre><code>function swap(array1, index1, index2) {
    var temp;
    temp = array1[index1];
    array1[index1] = array1[index2];
    array1[index2] = temp;
}

function permute(a, l, r) {
    var i;
    if (l == r) {
        console.log(a.join(''));
    } else {
        for (i = l; i &lt;= r; i++) {
            swap(a, l, i);
            permute(a, l + 1, r);
            swap(a, l, i);
        }
    }
}


permute(["A","B","C", "D"],0,3);
</code></pre>

<p>// sample execution
//for more details refer this link</p>

<p>// <a href="http://www.geeksforgeeks.org/write-a-c-program-to-print-all-permutations-of-a-given-string/" rel="nofollow">http://www.geeksforgeeks.org/write-a-c-program-to-print-all-permutations-of-a-given-string/</a></p>


blocks|key|230303|text|在精神上类似于@crl的Haskell风格的解决方案，但使用reduce|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|230304|function+permutations(+base+)+{
++if+(base.length+==+0)+return+[[]]
++return+permutations(+base.slice(1)+).reduce(+function(acc,perm)+{
++++return+acc.concat(+base.map(+function(e,pos)+{
++++++var+new_perm+=+perm.slice()
++++++new_perm.splice(pos,0,base[0])
++++++return+new_perm
++++}))
++},[])++++
}|code-block|syntax|javascript|230305|entityMap^0|U|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

<p>Similar in spirit to the Haskell-style solution by @crl, but working with <code>reduce</code>:</p>

<pre><code>function permutations( base ) {
  if (base.length == 0) return [[]]
  return permutations( base.slice(1) ).reduce( function(acc,perm) {
    return acc.concat( base.map( function(e,pos) {
      var new_perm = perm.slice()
      new_perm.splice(pos,0,base[0])
      return new_perm
    }))
  },[])    
}
</code></pre>


blocks|key|2894746|text|这是一项有趣的任务，这是我的贡献。这是非常简单和快速的。如果感兴趣，请耐心等待，继续阅读。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2894747|如果你想快速完成这项工作，你一定要让自己进入动态编程。这意味着你应该忘记递归方法。那是肯定的..。|2894748|到目前为止，使用堆方法的OK+le_m's+code似乎是最快的。我还没有给我的算法起个名字，我不知道它是否已经实现了，但它非常简单和快速。与所有动态编程方法一样，我们将从最简单的问题开始，并追求最终结果。|offset|length|2894749|假设我们有一个a+=+[1,2,3]数组，我们将从|style|CODE|2894750|r+=+[[1]];+//+result
t+=+[];++++//+interim+result|code-block|syntax|javascript|2894751|然后遵循这三个步骤；|2894752|2894753|对于r+(结果)数组的每一项，我们将添加输入数组的下一项。|ordered-list-item|2894754|我们将多次旋转每一项的长度，并将每个实例存储在中间结果数组t中。(除了第一个不浪费时间的0+rotation)|2894755|Once外，我们完成了r的所有项，中间数组t应该保存下一级结果，所以我们生成r+=+t;+t+=+[];，直到输入数组a.|2894756|的长度为止|2894757|下面是我们的步骤：|2894758|r+array+++%7C+push+next+item+to+%7C++get+length+many+rotations
++++++++++%7C++each+sub+array+++%7C+++++++of+each+subarray
-----------------------------------------------------------
[[1]]+++++%7C+++++[[1,2]]+++++++%7C+++++[[1,2],[2,1]]
----------%7C-------------------%7C----------------------------
[[1,2],+++%7C+++++[[1,2,3],+++++%7C+++++[[1,2,3],[2,3,1],[3,1,2],
+[2,1]]+++%7C++++++[2,1,3]]+++++%7C++++++[2,1,3],[1,3,2],[3,2,1]]
----------%7C-------------------%7C----------------------------
previous+t%7C+++++++++++++++++++%7C
-----------------------------------------------------------|2894759|下面是代码|2894760|​|2894761|function+perm(a){
++var+r+=+[[a[0]]],
++++++t+=+[],
++++++s+=+[];
++if+(a.length+<=+1)+return+a;
++for+(var+i+=+1,+la+=+a.length;+i+<+la;+i%2B%2B){
++++for+(var+j+=+0,+lr+=+r.length;+j+<+lr;+j%2B%2B){
++++++r[j].push(a[i]);
++++++t.push(r[j]);
++++++for(var+k+=+1,+lrj+=+r[j].length;+k+<+lrj;+k%2B%2B){
++++++++for+(var+l+=+0;+l+<+lrj;+l%2B%2B)+s[l]+=+r[j][(k%2Bl)%25lrj];
++++++++t[t.length]+=+s;
++++++++s+=+[];
++++++}
++++}
++++r+=+t;
++++t+=+[];
++}
++return+r;
}

var+arr+=+[0,1,2,4,5];
console.log("The+length+of+the+permutation+is:",perm(arr).length);
console.time("Permutation+test");
for+(var+z+=+0;+z+<+2000;+z%2B%2B)+perm(arr);
console.timeEnd("Permutation+test");|2894762|2894763|在多次测试中，我看到它在25~35ms内解析了0,1,2,3,4的120个排列2000次。|2894764|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/37580979/4543207^0|0|0|F|B|0|0|7|B|0|0|0|0|2|1|0|T|1|0|B|1|L|1|12|E|1N|1|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1P|8|@]|9|@$F|1Q|G|1R|1|1S]]|A|$]]|$1|H|3|I|5|6|7|1T|8|@$F|1U|G|1V|J|K]]|9|@]|A|$]]|$1|L|3|M|5|N|7|1W|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1X|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|T|3|U|5|V|7|1Z|8|@$F|20|G|21|J|K]]|9|@]|A|$]]|$1|W|3|X|5|V|7|22|8|@$F|23|G|24|J|K]]|9|@]|A|$]]|$1|Y|3|Z|5|V|7|25|8|@$F|26|G|27|J|K]|$F|28|G|29|J|K]|$F|2A|G|2B|J|K]|$F|2C|G|2D|J|K]]|9|@]|A|$]]|$1|10|3|11|5|6|7|2E|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|2F|8|@]|9|@]|A|$]]|$1|14|3|15|5|N|7|2G|8|@]|9|@]|A|$O|P]]|$1|16|3|17|5|6|7|2H|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2I|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|N|7|2J|8|@]|9|@]|A|$O|P]]|$1|1C|3|19|5|6|7|2K|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|2L|8|@]|9|@]|A|$]]|$1|1F|3|-4|5|6|7|2M|8|@]|9|@]|A|$]]]|1G|$1H|$5|1I|1J|1K|A|$1L|1M]]]]

<p>This is an interesting task and and here is my contribution. It's very simple and fast. If interested please bear with me and read on.</p>

<p>If you would like to this job fast, you definitely have to get yourself into dynamical programming. Which means you should forget about recursive approaches. That's for sure...</p>

<p>OK <a href="https://stackoverflow.com/a/37580979/4543207">le_m's code</a> which uses the Heap's method seems to be the fastest so far. Well i haven't got a name for my algorithm, i don't know  if it's already been implemented or not but it's very simple and fast. As with all dynamical programming approaches we will start with the simplest problem and go for the final result.</p>

<p>Assuming that we have an array of <code>a = [1,2,3]</code> we will start with</p>

<pre><code>r = [[1]]; // result
t = [];    // interim result
</code></pre>

<p>Then follow these three steps;</p>

<ol>
<li>For each item of our <code>r</code> (result) array we will add the next item of the input array.</li>
<li>We will rotate each item it's length many times and will store each instance at the interim result array <code>t</code>. (well except for the first one not to waste time with 0 rotation)</li>
<li>Once we finish with all items of <code>r</code> the interim array <code>t</code> should hold the next level of results so we make <code>r = t; t = [];</code> and carry on up until the length of the input array <code>a</code>.</li>
</ol>

<p>So the following are our steps;</p>

<pre><code>r array   | push next item to |  get length many rotations
          |  each sub array   |       of each subarray
-----------------------------------------------------------
[[1]]     |     [[1,2]]       |     [[1,2],[2,1]]
----------|-------------------|----------------------------
[[1,2],   |     [[1,2,3],     |     [[1,2,3],[2,3,1],[3,1,2],
 [2,1]]   |      [2,1,3]]     |      [2,1,3],[1,3,2],[3,2,1]]
----------|-------------------|----------------------------
previous t|                   |
-----------------------------------------------------------
</code></pre>

<p>So here is the code</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function perm(a){
  var r = [[a[0]]],
      t = [],
      s = [];
  if (a.length &lt;= 1) return a;
  for (var i = 1, la = a.length; i &lt; la; i++){
    for (var j = 0, lr = r.length; j &lt; lr; j++){
      r[j].push(a[i]);
      t.push(r[j]);
      for(var k = 1, lrj = r[j].length; k &lt; lrj; k++){
        for (var l = 0; l &lt; lrj; l++) s[l] = r[j][(k+l)%lrj];
        t[t.length] = s;
        s = [];
      }
    }
    r = t;
    t = [];
  }
  return r;
}

var arr = [0,1,2,4,5];
console.log("The length of the permutation is:",perm(arr).length);
console.time("Permutation test");
for (var z = 0; z &lt; 2000; z++) perm(arr);
console.timeEnd("Permutation test");</code></pre>
</div>
</div>
</p>

<p>In multiple test i have seen it resolving the 120 permutations of [0,1,2,3,4] for 2000 times in 25~35ms.</p>


blocks|key|3108669|text|这是map/reduce的一个非常好的用例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3108670|function+permutations(arr)+{
++++return+(arr.length+===+1)+?+arr+:
++++arr.reduce((acc,+cv,+index)+=>+{
++++++++let+remaining+=+[...arr];
++++++++remaining.splice(index,+1);
++++++++return+acc.concat(permutations(remaining).map(a+=>+[].concat(cv,a)));
++++},+[]);
}|code-block|syntax|javascript|3108671|首先，我们处理基本情况，如果其中只有on+|3108672|，则简单地返回数组。在所有其他情况下，|unordered-list-item|3108673|
|3108674|在input-array|3108675|3108676|and上创建一个空数组|3108677|3108678|循环，添加当前值和剩余数组的所有排列的数组。|3108679|3108680|​|3108681|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|13|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|14|8|@]|9|@]|A|$]]|$1|N|3|O|5|K|7|15|8|@]|9|@]|A|$]]|$1|P|3|M|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|K|7|17|8|@]|9|@]|A|$]]|$1|S|3|M|5|6|7|18|8|@]|9|@]|A|$]]|$1|T|3|U|5|K|7|19|8|@]|9|@]|A|$]]|$1|V|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1B|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|Z|$]]

<p>This is a very nice use-case for map/reduce:</p>

<pre><code>function permutations(arr) {
    return (arr.length === 1) ? arr :
    arr.reduce((acc, cv, index) =&gt; {
        let remaining = [...arr];
        remaining.splice(index, 1);
        return acc.concat(permutations(remaining).map(a =&gt; [].concat(cv,a)));
    }, []);
}
</code></pre>

<ul>
<li>First, we handle the base case and simply return the array if there is only on item in it</li>
<li>In all other cases

<ul>
<li>we create an empty array</li>
<li>loop over the input-array</li>
<li>and add an array of the current value and all permutations of the remaining array <code>[].concat(cv,a)</code></li>
</ul></li>
</ul>


blocks|key|235854|text|这里有一个非常简短的解决方案，它只适用于1到2个长字符串。它是一个线条，而且速度非常快，使用ES6而不依赖于jQuery。享受：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|235855|var+p+=+l+=>+l.length<2+?+[l]+:+l.length==2+?+[l[0]%2Bl[1],l[1]%2Bl[0]]+:+Function('throw+Error("unimplemented")')();|code-block|syntax|javascript|235856|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Here's a very short solution, that only works for 1 or 2 long strings. It's a oneliner, and it's blazing fast, using ES6 and not depending on jQuery. Enjoy:</p>

<pre><code>var p = l =&gt; l.length&lt;2 ? [l] : l.length==2 ? [l[0]+l[1],l[1]+l[0]] : Function('throw Error("unimplemented")')();
</code></pre>


blocks|key|233318|text|大多数其他答案都没有使用新的javascript生成器函数，这是此类问题的完美解决方案。在内存中，您可能一次只需要一个排列。此外，我更喜欢生成一系列索引的排列，因为这允许我索引每个排列，并直接跳到任何特定的排列，以及用于排列任何其他集合。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|233319|​|233320|//+ES6+generator+version+of+python+itertools+[permutations+and+combinations]
const+range+=+function*(l)+{+for+(let+i+=+0;+i+<+l;+i%2B=1)+yield+i;+}
const+isEmpty+=+arr+=>+arr.length+===+0;

const+permutations+=+function*(a)+{
++++const+r+=+arguments[1]+%7C%7C+[];
++++if+(isEmpty(a))+yield+r;
++++for+(let+i+of+range(a.length))+{
++++++++const+aa+=+[...a];
++++++++const+rr+=+[...r,+...aa.splice(i,+1)];
++++++++yield*+permutations(aa,+rr);
++++}
}
console.log('permutations+of+ABC');
console.log(JSON.stringify([...permutations([...'ABC'])]));

const+combinations+=+function*(a,+count)+{
++++const+r+=+arguments[2]+%7C%7C+[];
++++if+(count)+{
++++++++count+=+count+-+1;
++++++++for+(let+i+of+range(a.length+-+count))+{
++++++++++++const+aa+=+a.slice(i);
++++++++++++const+rr+=+[...r,+...aa.splice(0,+1)];
++++++++++++yield*+combinations(aa,+count,+rr);
++++++++}
++++}+else+{
++++++++yield+r;
++++}
}
console.log('combinations+of+2+of+ABC');
console.log(JSON.stringify([...combinations([...'ABC'],+2)]));



const+permutator+=+function()+{
++++const+range+=+function*(args)+{
++++++++let+{begin+=+0,+count}+=+args;
++++++++for+(let+i+=+begin;+count;+count--,+i%2B=1)+{
++++++++++++yield+i;
++++++++}
++++}
++++const+factorial+=+fact+=>+fact+?+fact+*+factorial(fact+-+1)+:+1;

++++return+{
++++++++perm:+function(n,+permutationId)+{
++++++++++++const+indexCount+=+factorial(n);
++++++++++++permutationId+=+((permutationId%25indexCount)%2BindexCount)%25indexCount;

++++++++++++let+permutation+=+[0];
++++++++++++for+(const+choiceCount+of+range({begin:+2,+count:+n-1}))+{
++++++++++++++++const+choice+=+permutationId+%25+choiceCount;
++++++++++++++++const+lastIndex+=+permutation.length;

++++++++++++++++permutation.push(choice);
++++++++++++++++permutation+=+permutation.map((cv,+i,+orig)+=>+
++++++++++++++++++++(cv+<+choice+%7C%7C+i+==+lastIndex)+?+cv+:+cv+%2B+1
++++++++++++++++);

++++++++++++++++permutationId+=+Math.floor(permutationId+/+choiceCount);
++++++++++++}
++++++++++++return+permutation.reverse();
++++++++},
++++++++perms:+function*(n)+{
++++++++++++for+(let+i+of+range({count:+factorial(n)}))+{
++++++++++++++++yield+this.perm(n,+i);
++++++++++++}
++++++++}
++++};
}();

console.log('indexing+type+permutator');
let+i+=+0;
for+(let+elem+of+permutator.perms(3))+{
++console.log(`${i}:+${elem}`);
++i%2B=1;
}
console.log();
console.log(`3:+${permutator.perm(3,3)}`);|code-block|syntax|javascript|233321|233322|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>Most of the other answers do not utilize the new javascript generator functions which is a perfect solution to this type of problem.  You probably only need one permutation at time in memory.  Also, I prefer to generate a permutation of a range of indices as this allows me to index each permutation and jump straight to any particular permutation as well as be used to permutate any other collection.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>// ES6 generator version of python itertools [permutations and combinations]
const range = function*(l) { for (let i = 0; i &lt; l; i+=1) yield i; }
const isEmpty = arr =&gt; arr.length === 0;

const permutations = function*(a) {
    const r = arguments[1] || [];
    if (isEmpty(a)) yield r;
    for (let i of range(a.length)) {
        const aa = [...a];
        const rr = [...r, ...aa.splice(i, 1)];
        yield* permutations(aa, rr);
    }
}
console.log('permutations of ABC');
console.log(JSON.stringify([...permutations([...'ABC'])]));

const combinations = function*(a, count) {
    const r = arguments[2] || [];
    if (count) {
        count = count - 1;
        for (let i of range(a.length - count)) {
            const aa = a.slice(i);
            const rr = [...r, ...aa.splice(0, 1)];
            yield* combinations(aa, count, rr);
        }
    } else {
        yield r;
    }
}
console.log('combinations of 2 of ABC');
console.log(JSON.stringify([...combinations([...'ABC'], 2)]));



const permutator = function() {
    const range = function*(args) {
        let {begin = 0, count} = args;
        for (let i = begin; count; count--, i+=1) {
            yield i;
        }
    }
    const factorial = fact =&gt; fact ? fact * factorial(fact - 1) : 1;

    return {
        perm: function(n, permutationId) {
            const indexCount = factorial(n);
            permutationId = ((permutationId%indexCount)+indexCount)%indexCount;

            let permutation = [0];
            for (const choiceCount of range({begin: 2, count: n-1})) {
                const choice = permutationId % choiceCount;
                const lastIndex = permutation.length;

                permutation.push(choice);
                permutation = permutation.map((cv, i, orig) =&gt; 
                    (cv &lt; choice || i == lastIndex) ? cv : cv + 1
                );

                permutationId = Math.floor(permutationId / choiceCount);
            }
            return permutation.reverse();
        },
        perms: function*(n) {
            for (let i of range({count: factorial(n)})) {
                yield this.perm(n, i);
            }
        }
    };
}();

console.log('indexing type permutator');
let i = 0;
for (let elem of permutator.perms(3)) {
  console.log(`${i}: ${elem}`);
  i+=1;
}
console.log();
console.log(`3: ${permutator.perm(3,3)}`);</code></pre>
</div>
</div>
</p>


blocks|key|3108754|text|++let+permutations+=+[]

++permutate([],+{
++++color:+['red',+'green'],
++++size:+['big',+'small',+'medium'],
++++type:+['saison',+'oldtimer']
++})

++function+permutate+(currentVals,+remainingAttrs)+{
++++remainingAttrs[Object.keys(remainingAttrs)[0]].forEach(attrVal+=>+{
++++++let+currentValsNew+=+currentVals.slice(0)
++++++currentValsNew.push(attrVal)

++++++if+(Object.keys(remainingAttrs).length+>+1)+{
++++++++let+remainingAttrsNew+=+JSON.parse(JSON.stringify(remainingAttrs))
++++++++delete+remainingAttrsNew[Object.keys(remainingAttrs)[0]]

++++++++permutate(currentValsNew,+remainingAttrsNew)
++++++}+else+{
++++++++permutations.push(currentValsNew)
++++++}
++++})
++}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3108755|结果：|unstyled|3108756|[+
++[+'red',+'big',+'saison'+],
++[+'red',+'big',+'oldtimer'+],
++[+'red',+'small',+'saison'+],
++[+'red',+'small',+'oldtimer'+],
++[+'red',+'medium',+'saison'+],
++[+'red',+'medium',+'oldtimer'+],
++[+'green',+'big',+'saison'+],
++[+'green',+'big',+'oldtimer'+],
++[+'green',+'small',+'saison'+],
++[+'green',+'small',+'oldtimer'+],
++[+'green',+'medium',+'saison'+],
++[+'green',+'medium',+'oldtimer'+]+
]|3108757|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>  let permutations = []

  permutate([], {
    color: ['red', 'green'],
    size: ['big', 'small', 'medium'],
    type: ['saison', 'oldtimer']
  })

  function permutate (currentVals, remainingAttrs) {
    remainingAttrs[Object.keys(remainingAttrs)[0]].forEach(attrVal =&gt; {
      let currentValsNew = currentVals.slice(0)
      currentValsNew.push(attrVal)

      if (Object.keys(remainingAttrs).length &gt; 1) {
        let remainingAttrsNew = JSON.parse(JSON.stringify(remainingAttrs))
        delete remainingAttrsNew[Object.keys(remainingAttrs)[0]]

        permutate(currentValsNew, remainingAttrsNew)
      } else {
        permutations.push(currentValsNew)
      }
    })
  }
</code></pre>

<p>Result:</p>

<pre><code>[ 
  [ 'red', 'big', 'saison' ],
  [ 'red', 'big', 'oldtimer' ],
  [ 'red', 'small', 'saison' ],
  [ 'red', 'small', 'oldtimer' ],
  [ 'red', 'medium', 'saison' ],
  [ 'red', 'medium', 'oldtimer' ],
  [ 'green', 'big', 'saison' ],
  [ 'green', 'big', 'oldtimer' ],
  [ 'green', 'small', 'saison' ],
  [ 'green', 'small', 'oldtimer' ],
  [ 'green', 'medium', 'saison' ],
  [ 'green', 'medium', 'oldtimer' ] 
]
</code></pre>


blocks|key|2894863|text|#!/usr/bin/env+node
"use+strict";

function+perm(arr)+{
++++if(arr.length<2)+return+[arr];
++++var+res+=+[];
++++arr.forEach(function(x,+i)+{
++++++++perm(arr.slice(0,i).concat(arr.slice(i%2B1))).forEach(function(a)+{
++++++++++++res.push([x].concat(a));
++++++++});
++++});
++++return+res;
}

console.log(perm([1,2,3,4]));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2894864|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>#!/usr/bin/env node
"use strict";

function perm(arr) {
    if(arr.length&lt;2) return [arr];
    var res = [];
    arr.forEach(function(x, i) {
        perm(arr.slice(0,i).concat(arr.slice(i+1))).forEach(function(a) {
            res.push([x].concat(a));
        });
    });
    return res;
}

console.log(perm([1,2,3,4]));
</code></pre>


blocks|key|2894869|text|const+removeItem+=+(arr,+i)+=>+{
++return+arr.slice(0,+i).concat(arr.slice(i%2B1));
}

const+makePermutations+=+(strArr)+=>+{
++const+doPermutation+=+(strArr,+pairArr)+=>+{
++++return+strArr.reduce((result,+permutItem,+i)+=>+{
++++++const+currentPair+=+removeItem(pairArr,+i);
++++++const+tempResult+=+currentPair.map((item)+=>+permutItem%2Bitem);
++++++return+tempResult.length+===+1+?+result.concat(tempResult)+:
+++++++++++++result.concat(doPermutation(tempResult,+currentPair));
++++},+[]);
++}
++return+strArr.length+===+1+?+strArr+:
+++++++++doPermutation(strArr,+strArr);
}


makePermutations(["a",+"b",+"c",+"d"]);
//result:+["abcd",+"abdc",+"acbd",+"acdb",+"adbc",+"adcb",+"bacd",+"badc",+"bcad",+"bcda",+"bdac",+"bdca",+"cabd",+"cadb",+"cbad",+"cbda",+"cdab",+"cdba",+"dabc",+"dacb",+"dbac",+"dbca",+"dcab",+"dcba"]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2894870|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>const removeItem = (arr, i) =&gt; {
  return arr.slice(0, i).concat(arr.slice(i+1));
}

const makePermutations = (strArr) =&gt; {
  const doPermutation = (strArr, pairArr) =&gt; {
    return strArr.reduce((result, permutItem, i) =&gt; {
      const currentPair = removeItem(pairArr, i);
      const tempResult = currentPair.map((item) =&gt; permutItem+item);
      return tempResult.length === 1 ? result.concat(tempResult) :
             result.concat(doPermutation(tempResult, currentPair));
    }, []);
  }
  return strArr.length === 1 ? strArr :
         doPermutation(strArr, strArr);
}


makePermutations(["a", "b", "c", "d"]);
//result: ["abcd", "abdc", "acbd", "acdb", "adbc", "adcb", "bacd", "badc", "bcad", "bcda", "bdac", "bdca", "cabd", "cadb", "cbad", "cbda", "cdab", "cdba", "dabc", "dacb", "dbac", "dbca", "dcab", "dcba"]
</code></pre>


blocks|key|2894874|text|这是一个最小的ES6版本。可以从Lodash中提取flatten和without函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2894875|const+flatten+=+xs+=>
++++xs.reduce((cum,+next)+=>+[...cum,+...next],+[]);

const+without+=+(xs,+x)+=>
++++xs.filter(y+=>+y+!==+x);

const+permutations+=+xs+=>
++++flatten(xs.map(x+=>
++++++++xs.length+<+2
++++++++++++?+[xs]
++++++++++++:+permutations(without(xs,+x)).map(perm+=>+[x,+...perm])
++++));|code-block|syntax|javascript|2894876|结果：|2894877|permutations([1,2,3])
//+[[1,+2,+3],+[1,+3,+2],+[2,+1,+3],+[2,+3,+1],+[3,+1,+2],+[3,+2,+1]]|2894878|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<p>Here is a minimal ES6 version. The flatten and without functions can be pulled from Lodash.</p>

<pre><code>const flatten = xs =&gt;
    xs.reduce((cum, next) =&gt; [...cum, ...next], []);

const without = (xs, x) =&gt;
    xs.filter(y =&gt; y !== x);

const permutations = xs =&gt;
    flatten(xs.map(x =&gt;
        xs.length &lt; 2
            ? [xs]
            : permutations(without(xs, x)).map(perm =&gt; [x, ...perm])
    ));
</code></pre>

<p>Result:</p>

<pre><code>permutations([1,2,3])
// [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
</code></pre>


blocks|key|2894880|text|perm+=+x+=>+x[0]+?++x.reduce((a,+n)+=>+(perm(x.filter(m+=>+m!=n)).forEach(y+=>+a.push([n,...y])),+a),+[]):+[[]]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2894881|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>perm = x =&gt; x[0] ?  x.reduce((a, n) =&gt; (perm(x.filter(m =&gt; m!=n)).forEach(y =&gt; a.push([n,...y])), a), []): [[]]
</code></pre>


blocks|key|230400|text|​|type|unstyled|depth|inlineStyleRanges|entityRanges|data|230401|const+permutations+=+array+=>+{
++let+permut+=+[];
++helperFunction(0,+array,+permut);
++return+permut;
};

const+helperFunction+=+(i,+array,+permut)+=>+{
++if+(i+===+array.length+-+1)+{
++++permut.push(array.slice());
++}+else+{
++++for+(let+j+=+i;+j+<+array.length;+j%2B%2B)+{
++++++swapElements(i,+j,+array);
++++++helperFunction(i+%2B+1,+array,+permut);
++++++swapElements(i,+j,+array);
++++}
++}
};

function+swapElements(a,+b,+array)+{
++let+temp+=+array[a];
++array[a]+=+array[b];
++array[b]+=+temp;
}

console.log(permutations([1,+2,+3]));|code-block|syntax|javascript|230402|230403|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|K|8|@]|9|@]|A|$E|F]]|$1|G|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const permutations = array =&gt; {
  let permut = [];
  helperFunction(0, array, permut);
  return permut;
};

const helperFunction = (i, array, permut) =&gt; {
  if (i === array.length - 1) {
    permut.push(array.slice());
  } else {
    for (let j = i; j &lt; array.length; j++) {
      swapElements(i, j, array);
      helperFunction(i + 1, array, permut);
      swapElements(i, j, array);
    }
  }
};

function swapElements(a, b, array) {
  let temp = array[a];
  array[a] = array[b];
  array[b] = temp;
}

console.log(permutations([1, 2, 3]));</code></pre>
</div>
</div>
</p>


blocks|key|2894900|text|很晚了。如果这对任何人有帮助的话，还是以防万一。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2894901|​|2894902|function+permute(arr)+{
++if+(arr.length+==+1)+return+arr

++let+res+=+arr.map((d,+i)+=>+permute([...arr.slice(0,+i),...arr.slice(i+%2B+1)])
++++++++++++++++++++++++++++++.map(v+=>+[d,v].join(''))).flat()

++return+res
}

console.log(permute([1,2,3,4]))|code-block|syntax|javascript|2894903|2894904|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>Quite late. Still just in case if this helps anyone.</p>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function permute(arr) {
  if (arr.length == 1) return arr

  let res = arr.map((d, i) =&gt; permute([...arr.slice(0, i),...arr.slice(i + 1)])
                              .map(v =&gt; [d,v].join(''))).flat()

  return res
}

console.log(permute([1,2,3,4]))</code></pre>
</div>
</div>
</p>


blocks|key|3108833|text|我试着编写了一个版本，试图简洁但可读，并且是纯函数式编程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3108834|function+stringPermutations+([...input])+{
++if+(input.length+===+1)+return+input;

++return+input
++++.map((thisChar,+index)+=>+{
++++++const+remainingChars+=+[...input.slice(0,+index),+...input.slice(index+%2B+1)];
++++++return+stringPermutations(remainingChars)
++++++++.map(remainder+=>+thisChar+%2B+remainder);
++++})
++++.reduce((acc,+cur)+=>+[...acc,+...cur]);
}|code-block|syntax|javascript|3108835|请注意，参数格式化将输入字符串转换为数组。不知道这是不是有点太神奇了..我不确定我在野外见过它。为了真正的可读性，我可能会在函数的第一行使用input+=+[...input]。|offset|length|style|CODE|3108836|entityMap^0|0|0|1Y|I|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<p>I had a crack at making a version of this that attempts to be concise yet readable, and purely functional programming.</p>

<pre><code>function stringPermutations ([...input]) {
  if (input.length === 1) return input;

  return input
    .map((thisChar, index) =&gt; {
      const remainingChars = [...input.slice(0, index), ...input.slice(index + 1)];
      return stringPermutations(remainingChars)
        .map(remainder =&gt; thisChar + remainder);
    })
    .reduce((acc, cur) =&gt; [...acc, ...cur]);
}
</code></pre>

<p>Note that the argument formatting turns an input string into an array. Not sure if that's a bit too <em>magical</em>.. Not sure I've seen it in the wild. For real readability I'd probably instead do <code>input = [...input]</code> for the first line of the function.</p>


blocks|key|3108847|text|这是一个很酷的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3108848|​|3108849|const+rotations+=+([l,+...ls],+right=[])+=>
++l+?+[[l,+...ls,+...right],+...rotations(ls,+[...right,+l])]+:+[]

const+permutations+=+([x,+...xs])+=>
++x+?+permutations(xs).flatMap((p)+=>+rotations([x,+...p]))+:+[[]]
++
console.log(permutations("cat"))|code-block|syntax|javascript|3108850|3108851|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<h1>Here's a cool solution</h1>

<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const rotations = ([l, ...ls], right=[]) =&gt;
  l ? [[l, ...ls, ...right], ...rotations(ls, [...right, l])] : []

const permutations = ([x, ...xs]) =&gt;
  x ? permutations(xs).flatMap((p) =&gt; rotations([x, ...p])) : [[]]
  
console.log(permutations("cat"))</code></pre>
</div>
</div>
</p>


blocks|key|230473|text|这是Heap算法的一个实现(类似于@le_m的算法)，只是它是递归的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|230474|function+permute_kingzee(arr,n=arr.length,out=[])+{
++++if(n+==+1)+{
++++++++return+out.push(arr.slice());
++++}+else+{
++++++++for(let+i=0;+i<n;+i%2B%2B)+{
++++++++++++permute_kingzee(arr,n-1,+out);
++++++++++++let+j+=+(+n+%25+2+==+0+)+?+i+:+0;
++++++++++++let+t+=+arr[n-1];
++++++++++++arr[n-1]+=+arr[j];
++++++++++++arr[j]+=+t;
++++++++}
++++++++return+out;
++++}
}|code-block|syntax|javascript|230475|它看起来也相当快：https://jsfiddle.net/3brqzaLe/|offset|length|230476|entityMap|0|LINK|mutability|MUTABLE|url|https://jsfiddle.net/3brqzaLe/^0|0|0|9|U|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<p>This is an implementation of Heap's algorithm (similar to @le_m's), except it's recursive.</p>

<pre><code>function permute_kingzee(arr,n=arr.length,out=[]) {
    if(n == 1) {
        return out.push(arr.slice());
    } else {
        for(let i=0; i&lt;n; i++) {
            permute_kingzee(arr,n-1, out);
            let j = ( n % 2 == 0 ) ? i : 0;
            let t = arr[n-1];
            arr[n-1] = arr[j];
            arr[j] = t;
        }
        return out;
    }
}
</code></pre>

<p>It looks like it's quite faster too : <a href="https://jsfiddle.net/3brqzaLe/" rel="nofollow noreferrer">https://jsfiddle.net/3brqzaLe/</a></p>


blocks|key|3108948|text|这是我做的..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3108949|const+permute+=+(ar)+=>
++ar.length+===+1+?+ar+:+ar.reduce(+(ac,_,i)+=>
++++{permute([...ar.slice(0,i),...ar.slice(i%2B1)]).map(v=>ac.push([].concat(ar[i],v)));+return+ac;},[]);|code-block|syntax|javascript|3108950|现在它又出现了，但写得不那么简洁！|3108951|function+permute(inputArray)+{
++if+(inputArray.length+===+1)+return+inputArray;
++return+inputArray.reduce(+function(accumulator,_,index){
++++permute([...inputArray.slice(0,index),...inputArray.slice(index%2B1)])
++++++.map(value=>accumulator.push([].concat(inputArray[index],value)));
++++return+accumulator;
++},[]);
}|3108952|它的工作原理:如果数组的长度超过一个元素，它将遍历每个元素，并通过递归调用将其连接起来，并将其余元素作为其参数。它不会改变原始数组。|3108953|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<p>Here's one I made...</p>

<pre><code>const permute = (ar) =&gt;
  ar.length === 1 ? ar : ar.reduce( (ac,_,i) =&gt;
    {permute([...ar.slice(0,i),...ar.slice(i+1)]).map(v=&gt;ac.push([].concat(ar[i],v))); return ac;},[]);
</code></pre>

<p>And here it is again but written less tersely!...</p>

<pre><code>function permute(inputArray) {
  if (inputArray.length === 1) return inputArray;
  return inputArray.reduce( function(accumulator,_,index){
    permute([...inputArray.slice(0,index),...inputArray.slice(index+1)])
      .map(value=&gt;accumulator.push([].concat(inputArray[index],value)));
    return accumulator;
  },[]);
}
</code></pre>

<p>How it works: If the array is longer than one element it steps through each element and concatenates it with a recursive call to itself with the remaining elements as it's argument. It doesn't mutate the original array.</p>


blocks|key|2895087|text|使用flatMap的函数式答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2895088|const+getPermutationsFor+=+(arr,+permutation+=+[])+=>
++arr.length+===+0
++++?+[permutation]
++++:+arr.flatMap((item,+i,+arr)+=>
++++++++getPermutationsFor(
++++++++++arr.filter((_,j)+=>+j+!==+i),
++++++++++[...permutation,+item]
++++++++)
++++++);|code-block|syntax|javascript|2895089|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>Functional answer using flatMap:</p>

<pre><code>const getPermutationsFor = (arr, permutation = []) =&gt;
  arr.length === 0
    ? [permutation]
    : arr.flatMap((item, i, arr) =&gt;
        getPermutationsFor(
          arr.filter((_,j) =&gt; j !== i),
          [...permutation, item]
        )
      );
</code></pre>


blocks|key|2895127|text|我使用字符串而不是数组，似乎我的算法消耗的时间很少。我在这里发布了我的算法，我测量的时间正确吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2895128|console.time('process');

var+result+=+[]

function+swapper(toSwap){
++++let+start+=+toSwap[0]
++++let+end+=+toSwap.slice(1)
++++return+end+%2B+start
}


function+perm(str){
++++let+i+=+str.length
++++let+filling+=+i+-+1

++++let+buckets+=+i*filling
++++let+tmpSwap+=+''
++++for(let+j=0;+j<filling;+j%2B%2B){
++++++++if(j===0){
++++++++++++result.push(str)
++++++++}else{
++++++++++if(j+===+1){
++++++++++++++tmpSwap+=+swapper(str.slice(1))
++++++++++++++result.push(str[0]%2B+tmpSwap)
++++++++++++++if(j+===+filling-1+&&+result.length+<+buckets){
++++++++++++++++++perm(swapper(str))
++++++++++++++}

++++++++++}else{
++++++++++++++tmpSwap+=+swapper(tmpSwap)
++++++++++++++result.push(str[0]%2B+tmpSwap)
++++++++++++++if(j+===+filling-1+&&+result.length+<+buckets){
++++++++++++++++++perm(swapper(str))
++++++++++++++}
++++++++++}
++++++++}
++++}

++++if(result.length+=+buckets){
++++++return+result
++++}else{
++++++return+'something+went+wrong'
++++}

}





console.log(perm('abcdefghijk'))

console.timeEnd('process');|code-block|syntax|javascript|2895129|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I used a string instead of an array and it seems like my algorithm consumes very less time. I am posting my algorithm here, am I measuring the time correctly?</p>

<pre><code>console.time('process');

var result = []

function swapper(toSwap){
    let start = toSwap[0]
    let end = toSwap.slice(1)
    return end + start
}


function perm(str){
    let i = str.length
    let filling = i - 1

    let buckets = i*filling
    let tmpSwap = ''
    for(let j=0; j&lt;filling; j++){
        if(j===0){
            result.push(str)
        }else{
          if(j === 1){
              tmpSwap = swapper(str.slice(1))
              result.push(str[0]+ tmpSwap)
              if(j === filling-1 &amp;&amp; result.length &lt; buckets){
                  perm(swapper(str))
              }

          }else{
              tmpSwap = swapper(tmpSwap)
              result.push(str[0]+ tmpSwap)
              if(j === filling-1 &amp;&amp; result.length &lt; buckets){
                  perm(swapper(str))
              }
          }
        }
    }

    if(result.length = buckets){
      return result
    }else{
      return 'something went wrong'
    }

}





console.log(perm('abcdefghijk'))

console.timeEnd('process');
</code></pre>


blocks|key|230511|text|最快，最(资源)有效，最优雅的版本(2020)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|230512|​|230513|function+getArrayMutations+(arr,+perms+=+[],+len+=+arr.length)+{
++if+(len+===+1)+perms.push(arr.slice(0))

++for+(let+i+=+0;+i+<+len;+i%2B%2B)+{
++++getArrayMutations(arr,+perms,+len+-+1)

++++len+%25+2+//+parity+dependent+adjacent+elements+swap
++++++?+[arr[0],+arr[len+-+1]]+=+[arr[len+-+1],+arr[0]]
++++++:+[arr[i],+arr[len+-+1]]+=+[arr[len+-+1],+arr[i]]
++}

++return+perms
}

const+arrayToMutate+=+[1,+2,+3,+4,+5,+6,+7,+8,+9]

const+startTime+=+performance.now()
const+arrayOfMutations+=+getArrayMutations(arrayToMutate)
const+stopTime+=+performance.now()
const+duration+=+(stopTime+-+startTime)+/+1000

console.log(`${arrayOfMutations.length.toLocaleString('en-US')}+permutations+found+in+${duration.toLocaleString('en-US')}s`)|code-block|syntax|javascript|230514|230515|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

<p>Fastest, most (resorces) effective and most elegant version nowadays (2020)</p>
<p><div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function getArrayMutations (arr, perms = [], len = arr.length) {
  if (len === 1) perms.push(arr.slice(0))

  for (let i = 0; i &lt; len; i++) {
    getArrayMutations(arr, perms, len - 1)

    len % 2 // parity dependent adjacent elements swap
      ? [arr[0], arr[len - 1]] = [arr[len - 1], arr[0]]
      : [arr[i], arr[len - 1]] = [arr[len - 1], arr[i]]
  }

  return perms
}

const arrayToMutate = [1, 2, 3, 4, 5, 6, 7, 8, 9]

const startTime = performance.now()
const arrayOfMutations = getArrayMutations(arrayToMutate)
const stopTime = performance.now()
const duration = (stopTime - startTime) / 1000

console.log(`${arrayOfMutations.length.toLocaleString('en-US')} permutations found in ${duration.toLocaleString('en-US')}s`)</code></pre>
</div>
</div>
</p>


blocks|key|3109076|text|这里有一个非常简洁和递归的解决方案，它允许您输入输出排列的大小，类似于统计运算符nPr。"5排列3“。这允许您获得特定大小的所有可能的排列。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3109077|function+generatePermutations(list,+size=list.length)+{
++++if+(size+>+list.length)+return+[];
++++else+if+(size+==+1)+return+list.map(d=>[d]);+
++++return+list.flatMap(d+=>+generatePermutations(list.filter(a+=>+a+!==+d),+size+-+1).map(item+=>+[d,+...item]));
}|code-block|syntax|javascript|3109078|generatePermutations([1,2,3])|offset|length|style|CODE|3109079|[[1,+2,+3],[1,+3,+2],+[2,+1,+3],+[2,+3,+1],+[3,+1,+2],+[3,+2,+1]]|3109080|generatePermutations([1,2,3],2)|3109081|[[1,+2],+[1,+3],+[2,+1],+[2,+3],+[3,+1],+[3,+2]]|3109082|entityMap^0|0|0|0|T|0|0|0|V|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@$I|11|J|12|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

<p>Here's a very concise and recursive solution that allows you to input the size of the output permutations similar to the statistical operator nPr. &quot;5 permutation 3&quot;. This allows you to get all possible permutations with a specific size.</p>
<pre><code>function generatePermutations(list, size=list.length) {
    if (size &gt; list.length) return [];
    else if (size == 1) return list.map(d=&gt;[d]); 
    return list.flatMap(d =&gt; generatePermutations(list.filter(a =&gt; a !== d), size - 1).map(item =&gt; [d, ...item]));
}
</code></pre>
<p><code>generatePermutations([1,2,3])</code></p>
<pre><code>[[1, 2, 3],[1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
</code></pre>
<p><code>generatePermutations([1,2,3],2)</code></p>
<pre><code>[[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]]
</code></pre>


blocks|key|236024|text|这只是delimited的更简洁一点的版本|type|unstyled|depth|inlineStyleRanges|entityRanges|data|236025|function+permutator+(inputArr)+{
++const+result+=+[]

++function+permute+(arr,+m+=+[])+{
++++if+(arr.length)+{
++++++arr.forEach((item,+i)+=>+{
++++++++const+restArr+=+[...arr.slice(0,+i),+...arr.slice(i+%2B+1)]
++++++++permute(restArr,+[...m,+item])
++++++})
++++}+else+{
++++++result.push(m)
++++}
++}

++permute(inputArr)

++return+result
}|code-block|syntax|javascript|236026|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>This is just little bit more succinct version of delimited's</p>
<pre class="lang-js prettyprint-override"><code>function permutator (inputArr) {
  const result = []

  function permute (arr, m = []) {
    if (arr.length) {
      arr.forEach((item, i) =&gt; {
        const restArr = [...arr.slice(0, i), ...arr.slice(i + 1)]
        permute(restArr, [...m, item])
      })
    } else {
      result.push(m)
    }
  }

  permute(inputArr)

  return result
}
</code></pre>


blocks|key|3109258|text|我认为下面的解决方案中唯一的不同之处在于，我在null+case之前停止了一步递归。希望嵌入的注释是足够的解释。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3109259|function+Permutations+(A)+//+computes+all+possible+ordered+sequences+of+the+entries+in+array+A+and+returns+them+as+an+array+of+arrays
{
var+perms+=+[];

for+(var+i+=+0+;+i+<+A.length+;+i%2B%2B)
++++{
++++var+rem+=+A.slice+(0);+//+copy+input+array+to+retain+remainder+of+elements+after+removing+i'th+element
++++var+el+=+rem.splice+(i,1);
++++if+(A.length+==+2)+{perms.push+([el+[0],rem+[0]])}+//+recursion+end+case
++++else+
++++++++{
++++++++var+sub+=+Permutations+(rem);+//+recursive+call
++++++++for+(var+s+=+0+;+s+<+sub.length+;+s%2B%2B)+//+process+recursive+response,+adding+el+to+the+start+of+each+returned+sequence
++++++++++++{
++++++++++++sub+[s].splice+(0,0,el+[0]);
++++++++++++perms.push+(sub+[s]);
++++++++++++};
++++++++};
++++};

return+perms+;

};//+end+of+Permutations+function|code-block|syntax|javascript|3109260|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

<p>I think perhaps the only difference in my solution below is that I stop the recursion one step before the null case. Hopefully the embedded comments are sufficient explanation.</p>
<pre><code>function Permutations (A) // computes all possible ordered sequences of the entries in array A and returns them as an array of arrays
{
var perms = [];

for (var i = 0 ; i &lt; A.length ; i++)
    {
    var rem = A.slice (0); // copy input array to retain remainder of elements after removing i'th element
    var el = rem.splice (i,1);
    if (A.length == 2) {perms.push ([el [0],rem [0]])} // recursion end case
    else 
        {
        var sub = Permutations (rem); // recursive call
        for (var s = 0 ; s &lt; sub.length ; s++) // process recursive response, adding el to the start of each returned sequence
            {
            sub [s].splice (0,0,el [0]);
            perms.push (sub [s]);
            };
        };
    };

return perms ;

};// end of Permutations function
</code></pre>


<p>I'm trying to write a function that does the following:</p>

<ul>
<li>takes an array of integers as an argument (e.g. [1,2,3,4])</li>
<li>creates an array of all the possible permutations of [1,2,3,4], with each permutation having a length of 4</li>
</ul>

<p>the function below (I found it online) does this by taking a string as an argument, and returning all the permutations of that string</p>

<p>I could not figure out how to modify it to make it work with an array of integers, (I think this has something to do with how some of the methods work differently on strings than they do on integers, but I'm not sure...)</p>

<pre><code>var permArr = [], usedChars = [];
function permute(input) {
  var i, ch, chars = input.split("");
  for (i = 0; i &lt; chars.length; i++) {
    ch = chars.splice(i, 1);
    usedChars.push(ch);
    if (chars.length == 0)
      permArr[permArr.length] = usedChars.join("");
    permute(chars.join(""));
    chars.splice(i, 0, ch);
    usedChars.pop();
  }
  return permArr
};
</code></pre>

<p>Note: I'm looking to make the function return arrays of <em>integers</em>, <strong>not</strong> an array of <em>strings</em>.</p>

<p>I really need the solution to be in JavaScript. I've already figured out how to do this in python</p>


Permutations in JavaScript?

jQuery

JSON

我正在尝试编写一个执行以下操作的函数：采用整数数组作为参数(例如，1,2,3,4)creates包含1、2、3、4的所有可能排列的数组，每个排列的长度为4下面的函数(我是在网上找到的)通过将一个字符串作为参数，并返回该字符串的所有排列来实现此目的我不知道如何修改它以使其与整数数组一起工作(我认为这与一些方法在字符串上的...

问JavaScript中的排列？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JavaScript中的排列？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JavaScript中的排列？
EN