JavaScriptの順列？

138

私は次のことをする関数を書こうとしています：

  • 引数として整数の配列を取ります（例[1,2,3,4]）
  • [1,2,3,4]の可能なすべての順列の配列を作成します。各順列の長さは4です。

以下の関数（オンラインで見つけた）は、文字列を引数として取り、その文字列のすべての順列を返すことでこれを行います

整数の配列で機能するように変更する方法を理解できませんでした（これは、一部のメソッドが文字列で整数とは異なる動作をする方法と関係があると思いますが、よくわかりません。 ..）

var permArr = [], usedChars = [];
function permute(input) {
  var i, ch, chars = input.split("");
  for (i = 0; i < 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
};

注：私はの関数の戻りアレイ作るために探してい整数を、ないの配列の文字列。

私は本当にJavaScriptで解決する必要があります。私はすでにこれをPythonで行う方法を理解しています

javascript  permutation 
— コショウドリーム
ソース

回答:

106

気付いた場合、コードは実際に置換を行う前に文字を配列に分割するため、結合と分割の操作を削除するだけです。

var permArr = [],
  usedChars = [];

function permute(input) {
  var i, ch;
  for (i = 0; i < 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])));
スニペットを展開

— アンドレアス・ウォン
ソース
@SiGanteng。あなたの機能を使おうとしている私に奇妙なことが起こっています。私はすべての「リスト操作関数」を持っている.jsにそれを保持します。私がそれをpermute（[1,2,3]）で使用し、後でpermute（[4,5,6]）を使用した場合、後者の出力には、最初の出力の結果が残っています。それを修正する方法はありますか？どうもありがとう ！
— 500
3
— アンダーソングリーン
15
関数内のグローバルへのアクセス、不正な形式！
— Shmiddty
123

少し遅れましたが、少しエレガントなバージョンをここに追加したいと思います。任意の配列にすることができます...

function permutator(inputArr) {
  var results = [];

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

    for (var i = 0; i < 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);
}

ES6（2015）バージョンの追加。また、元の入力配列を変更しません。Chromeのコンソールで動作します...

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++) {
        let curr = arr.slice();
        let next = curr.splice(i, 1);
        permute(curr.slice(), m.concat(next))
     }
   }
 }

 permute(inputArr)

 return result;
}

そう...

permutator(['c','a','t']);

収量...

[ [ 'c', 'a', 't' ],
  [ 'c', 't', 'a' ],
  [ 'a', 'c', 't' ],
  [ 'a', 't', 'c' ],
  [ 't', 'c', 'a' ],
  [ 't', 'a', 'c' ] ]

そして...

permutator([1,2,3]);

収量...

[ [ 1, 2, 3 ],
  [ 1, 3, 2 ],
  [ 2, 1, 3 ],
  [ 2, 3, 1 ],
  [ 3, 1, 2 ],
  [ 3, 2, 1 ] ]
— 区切られた
ソース
1
（おそらくあなたは順列を扱っている考えるとかなりあるよう）あなたが便利な階乗関数を使用している場合は、に、外側のスコープの初期化を変更することで、それをスピードアップすることができ var results = new Array(factorial(inputArr.length)), length=0、次に置き換える、results.push(…)とresults[length++]=…
— Cyoce
1
line var cur, memo = memo || [];は何をしますか？
— Ricevind
2
@ user2965967これはcurとmemoを宣言し、false（未定義を含む）でない限り、memoをmemoの値に初期化します。この場合、空の配列になります。つまり、関数パラメータにデフォルト値を提供するのは理想的とは言えません。
— Lavalamp氏、16年
これにより、元の配列が変更されます。
— Shmiddty
2
あるslice()にpermute(curr.slice(), m.concat(next))本当に必要？
— Yoav 2018
82

次の非常に効率的なアルゴリズムは、ヒープのメソッドを使用して、O（N！）で実行時の複雑さを伴うN要素のすべての順列を生成します。

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 % 2 && 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]));
スニペットを展開

O（N）で空間が複雑なジェネレーターとして実装された同じアルゴリズム：

コードスニペットを表示

性能比較

実装を次のbenchmark.jsテストスイートに追加してください：

コードスニペットを表示

Chrome 48の実行時結果：

— le_m
ソース
1
このコードを変更して、n = 2の固定の結果を提供するにはどうすればよいですか？たとえば、A、B、Cの3つの文字のセットがあるとします。そのセットから2つの文字を配置する方法をいくつ尋ねるかもしれません。それぞれの可能な配置は順列の例です。可能な順列の完全なリストは、AB、AC、BA、BC、CA、およびCBです。
— a4xrbj1
1
@ a4xrbj1この問題の例のサンプルコードを参照してください： stackoverflow.com/questions/37892738/...を -かは、具体的には、この（ヒープの）メソッドを修正について尋ねていますか？
— le_m 2016年
@le_mはい、特にこの（ヒープ）メソッドは非常に高速なので使用します
— a4xrbj1
@ a4xrbj1 Iは、固定長さNのすべての組み合わせを計算するであろう（例えば、AB、AC、BC N = 2の場合）上に与えられたリンクと同様の戦略を用いて（参照stackoverflow.com/questions/127704/...）と、各組み合わせについてヒープの方法を使用して、すべての順列を計算します。もちろん、n = 2などの特殊なケースを最適化できます。
— le_m 2016年
1
ジェネレーターのバージョンは正しく機能yield permutation.slice()しません。スライスしない場合は、最後の順列のみが計算されます。
— ベルダー
41 
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 + 1)).reduce(permute, []).map(function(perm) { return [item].concat(perm); }) || item);
}, []);


alert(JSON.stringify(result));
— モンキー
ソース
10
うわー、その簡潔さとドキュメントの欠如にもかかわらず、私はこれが最もエレガントな答えだと思います。このアルゴリズムについての私の説明は、配列内のすべてのアイテム（reduce）について、他のすべてのアイテムを選択し、それらを（再帰的に）並べ替え、このアイテムに連結します。
— アーロン2014年
ここでこのソリューションを試してみました：codewars.com/kata/reviews/5254ca2719453dcc0b000280/groups/…元のゴルフコードを解読可能なコードに展開しましたが、基本的には同じです。それの問題は、それが重複を生成することであり、私は.filter(uniq)結果に追加をしなければなりませんでした。
— Andrey Mikhaylov-lolmaus
1
コンセプトと並行するLispがあります[1,2,3].length == 3 && "foo" || "bar"か[1,2].length == 3 && "foo" || "bar"？有る！(or (and (= 3 2) (print "hello!")) (print "goodbye"))
— ドミトリー
@ lolmaus-AndreyMikhaylov重複を削除する方法可能であれば回答を更新してください
— Pardeep Jain
@PardeepJain上記の私のソリューションへのリンクを提供しました。
— Andrey Mikhaylov-lolmaus
21

SiGantengの回答を改善しました。

とは毎回クリアされるpermuteためpermArr、今では複数回呼び出すことが可能usedCharsです。

function permute(input) {
    var permArr = [],
        usedChars = [];
    return (function main() {
        for (var i = 0; i < 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;
    })();
}

コードスニペットを表示

— オリオール
ソース
10

次の関数は、任意のタイプの配列を順列し、見つかった順列ごとに指定されたコールバック関数を呼び出します。

/*
  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 < 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);
  }

次のように呼び出すと、

  // 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);

私はそれがあなたが必要とするものを正確に行うと思います-呼び出された配列に配列resultの順列を入れます[1、2、3]。結果は次のとおりです。

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

JSFiddleの少し明確なコード：http ://jsfiddle.net/MgmMg/6/

— MarkusT
ソース
10

この質問に対するほとんどの回答は、配列内の項目の継続的な挿入と削除、または配列の繰り返しコピーなどの高価な操作を使用します。

代わりに、これは典型的なバックトラッキングソリューションです。

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; ++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;
}
permute([1,2,3,4]); // [  [1,2,3,4], [1,2,4,3], /* ... , */ [4,3,2,1]  ]

結果の配列は巨大になるため、すべてのデータを同時に割り当てるのではなく、結果を1つずつ反復することをお勧めします。ES6では、これはジェネレーターで実行できます。

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; ++i) if(!used[i]) {
      used[i] = true;
      data[pos] = arr[i];
      yield* backtracking(pos+1);
      used[i] = false;
    }
  }(0);
}
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}
— オリオール
ソース
6

これは興味深いタスクであり、これが私の貢献です。それは非常にシンプルで高速です。興味があれば私と一緒に読んでください。

この仕事を早くしたいのなら、間違いなく動的プログラミングに取り掛かる必要があります。つまり、再帰的なアプローチは忘れてください。それは確かだ...

OK le_mのコードヒープのメソッドを使用して、これまで最速のようです。アルゴリズムの名前はわかりませんが、すでに実装されているかどうかはわかりませんが、非常にシンプルで高速です。すべての動的プログラミングアプローチと同様に、最も単純な問題から始めて、最終結果を求めます。

我々は、配列を持っていると仮定するとa = [1,2,3]、我々が始まります

r = [[1]]; // result
t = [];    // interim result

次に、次の3つの手順に従います。

  1. の各アイテム r（結果）配列の、入力配列の次の項目を追加します。
  2. 各項目を何回も回転させ、各インスタンスを中間結果配列に格納します tます。（0回転で時間を無駄にしない最初のものを除いて）
  3. r暫定配列のすべての項目が完了するとt、次のレベルの結果を保持する必要があるためr = t; t = [];、入力配列の長さまで作成して続行しますa。

したがって、以下は私たちのステップです。

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|                   |
-----------------------------------------------------------

これがコードです

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++){
    for (var j = 0, lr = r.length; j < lr; j++){
      r[j].push(a[i]);
      t.push(r[j]);
      for(var k = 1, lrj = r[j].length; k < lrj; k++){
        for (var l = 0; l < 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 < 2000; z++) perm(arr);
console.timeEnd("Permutation test");
スニペットを展開

複数のテストで、[0,1,2,3,4]の120の順列を25〜35ミリ秒で2000回解決するのを見ました。

— レドゥ
ソース
1
FF / UbuntuのHeapメソッドよりも、実際には高速で実行される場合があります。異なる長さ/ウォームアップの反復などでは、ヒープメソッドよりも低速です。異なるエンジンの結果を表示するには、jsperfが必要です。
— le_m 2017年
1
@le_m OK私はいくつかのテストを行いました@UbuntuとAMD CPUで@JSBen：Chromeを使用するとrotatePerm（上記のもの）は一貫して1.2高速です。FFでは一貫性はありません。複数のテストを行った後、heapPerm2倍速くなる場合rotatePermと1.1倍速くなる場合があります。OperaやEpiphanyなどの他のWebキットブラウザーを使用すると、rotatePerm一貫して1.1倍高速になります。ただし、Edge heapPermでは常に毎回1.2倍高速です。
— Redu
1
いいね！少なくともFF / Ubuntuでは、ヒープメソッドのパフォーマンスは主に配列コピーのパフォーマンスに依存しているようです。スライシングとプッシュを比較するようにベンチマークを変更しました：jsben.ch / # / x7mYh -FFでは小さな入力配列の場合、プッシュははるかに高速に見えます
— le_m
2
ヒープ方式がパフォーマンスの面で打撃を受けることができれば素晴らしいでしょう。ところで、あなたの方法は、私はヒープの方法の基準として使用されるのと同じ1977紙からラングドンのアルゴリズム（16ページ）と同じ出力を生成します。homepage.math.uiowa.edu/~goodman/22m150.dir/2007/...を
— le_m
2
@le_mたった今チェックしたところ、同じようです。私は彼が実装したように回転をしているようです。ちょうど40年遅れで。私の答えで述べたように、それは実際には非常に単純な方法です。高速回転が可能な場合にのみ選択できると記載されています。現在私はHaskellに参加しており、リスト（配列と言いましょう）を無制限に循環させる組み込みメソッドがあり（遅延評価では無限反復は問題になりません）、これは便利な場合があります。しかし、Haskellにはすでに標準permutations機能があります:)
— Redu
6

Haskellから着想を得たバージョン：

perms [] = [[]]
perms xs = [ x:ps | x <- xs , ps <- perms ( xs\\[x] ) ]

function perms(xs) {
  if (!xs.length) return [[]];
  return xs.flatMap((xi, i) => {
    // get permutations of xs without its i-th item, then prepend xi to each
    return perms([...xs.slice(0,i), ...xs.slice(i+1)]).map(xsi => [xi, ...xsi]);
  });
}
document.write(JSON.stringify(perms([1,2,3])));
スニペットを展開

— カウブ
ソース
5

外部アレイや追加機能を必要とせずに答えます

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

  for (var i = 0; i <  arr.length; i++) { 
    var subPerms = permutator(arr.slice(0, i).concat(arr.slice(i + 1)));
    for (var j = 0; j < subPerms.length; j++) {
      subPerms[j].unshift(arr[i]);
      permutations.push(subPerms[j]);
    }
  }
  return permutations;
}
— テイラー・ヘイクス
ソース
あなたはそれからコンビネーションを作ることができますか？stackoverflow.com/questions/53555563/...
— Techdive
5

今日（2020）、最も速く、最も（効果的な）効果的で最もエレガントなバージョン

function getArrayMutations(arr, perms = [], len = arr.length) {
  if (len === 1) perms.push(arr.slice(0))

  for (let i = 0; i < 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`)
スニペットを展開

— ウラジスラフ・ラディキー
ソース
こんにちは、どういうlen % 2 // parity dependent adjacent elements swap意味で、どうしてそれを使うのか説明していただけませんか？
— Pramesh Bajracharya
私のコードでは、「ヒープのアルゴリズム」を使用して配列の置換を生成しています。したがって、私のコードが内部で
— Vladislav Ladicky
結果を印刷してみましたか？配列要素が10を超える場合の最大値の制御方法
— Marvix
4

ここにクールなソリューションがあります

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"))
スニペットを展開

— クリス・ヴォーガ
ソース
2

これは別の「より再帰的な」ソリューションです。

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; ++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);
スニペットを展開

出力：

[ 'ABC', 'BAC', 'BCA', 'ACB', 'CAB', 'CBA' ]
— ひよこ
ソース
あなたはそれを組み合わせることができますか？stackoverflow.com/questions/53555563/...
— Techdive
2 
   function perm(xs) {
       return xs.length === 0 ? [[]] : perm(xs.slice(1)).reduce(function (acc, ys) {
        for (var i = 0; i < xs.length; i++) {
          acc.push([].concat(ys.slice(0, i), xs[0], ys.slice(i)));
        }
        return acc;
      }, []);
    }

それをテストします：

console.log(JSON.stringify(perm([1, 2, 3,4])));
— eb58
ソース
2

他のほとんどの回答は、この種の問題の完璧な解決策である新しいJavaScriptジェネレーター関数を利用していません。おそらく、メモリ内で一度に必要な順列は1つだけです。また、インデックスの範囲の順列を生成することをお勧めします。これにより、各順列にインデックスを付け、特定の順列に直接ジャンプしたり、他のコレクションの順列に使用したりできるようになります。

// ES6 generator version of python itertools [permutations and combinations]
const range = function*(l) { for (let i = 0; i < l; i+=1) yield i; }
const isEmpty = arr => 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 => 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) => 
                    (cv < 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)}`);
スニペットを展開

— ダグ・コバーン
ソース
2 
#!/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+1))).forEach(function(a) {
            res.push([x].concat(a));
        });
    });
    return res;
}

console.log(perm([1,2,3,4]));
— dashxdr
ソース
2

これが私が作ったものです...

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

そして、ここでもう一度ですが、簡潔に書かれています！...

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=>accumulator.push([].concat(inputArray[index],value)));
    return accumulator;
  },[]);
}

仕組み：配列が1つの要素よりも長い場合は、各要素を順番に調べ、残りの要素を引数として、それ自体への再帰呼び出しで連結します。元の配列は変更されません。

— ロジャー・ヒースコート
ソース
2

flatMapを使用した機能的な答え：

const getPermutationsFor = (arr, permutation = []) =>
  arr.length === 0
    ? [permutation]
    : arr.flatMap((item, i, arr) =>
        getPermutationsFor(
          arr.filter((_,j) => j !== i),
          [...permutation, item]
        )
      );
— ジャブサッツ
ソース
1 

"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 + 1; i<length; i++){
           for(let j = i + 1; j < length; j++){
               if(arr[i] > 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+', '});
textarea{
   height:500px;
  width:500px;
}
<textarea id='myTxtArr'></textarea>
スニペットを展開

辞書式に順序付けられた順列を出力します。数字でのみ機能します。それ以外の場合は、34行目でswapメソッドを変更する必要があります。

— タマズ・バグダバゼ
ソース
1

精神的には@crlによるHaskellスタイルのソリューションに似ていますが、以下を使用しreduceます。

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
    }))
  },[])    
}
— ルプランティコ
ソース
1

これは、map / reduceの非常に優れた使用例です。

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)));
    }, []);
}
  • まず、基本ケースを処理し、そこに項目のみが存在する場合は、単に配列を返します
  • 他のすべての場合
    • 空の配列を作成します
    • 入力配列をループします
    • 現在の値の配列と残りの配列のすべての順列を追加します [].concat(cv,a)
— ダニエルブエチェレ
ソース
1

これは最小のES6バージョンです。フラット化された関数なしの関数は、Lodashからプルできます。

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])
    ));

結果：

permutations([1,2,3])
// [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]
— マートンサリ
ソース
1 
perm = x => x[0] ?  x.reduce((a, n) => (perm(x.filter(m => m!=n)).forEach(y => a.push([n,...y])), a), []): [[]]
— eb58
ソース
2
説明をお願いします。
— Mehdi Bounya
3
この回答は問題を解決する可能性がありますが、その方法や理由の説明は含まれていません。
— samlev
1 

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++) {
      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]));
スニペットを展開

— ASHISH RANJAN
ソース
1

かなり遅く。これが誰かを助ける場合に備えて。

function permute(arr) {
  if (arr.length == 1) return arr

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

  return res
}

console.log(permute([1,2,3,4]))
スニペットを展開

— ニティッシュ・ナラン
ソース
1

私は、簡潔でありながら読みやすく、純粋に関数型のプログラミングをしようとするこのバージョンの作成に亀裂がありました。

function stringPermutations ([...input]) {
  if (input.length === 1) return input;

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

引数のフォーマットは、入力文字列を配列に変換することに注意してください。少し不思議なことかどうかはわかりませんが、野生で見たことはありません。実際の読みやすさのinput = [...input]ために、私はおそらく代わりに関数の最初の行に対して行うでしょう。

— ジェームスロール
ソース
1

これは、再帰的であることを除いて、ヒープのアルゴリズム（@le_mと同様）の実装です。

function permute_kingzee(arr,n=arr.length,out=[]) {
    if(n == 1) {
        return out.push(arr.slice());
    } else {
        for(let i=0; i<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;
    }
}

それもかなり速いようです：https : //jsfiddle.net/3brqzaLe/

— ジー
ソース
1

サイトへの私の最初の貢献。また、私が行ったテストによると、このコードはこの日付以前にここで説明した他のすべてのメソッドよりも高速に実行されます。もちろん、値が少ない場合は最小限ですが、追加しすぎると時間は指数関数的に増加します。

function permutations(arr) {
    var finalArr = [];
    function iterator(arrayTaken, tree) {
        var temp;
        for (var i = 0; i < tree; i++) {
            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 + 1);
            }
        }
    }
    iterator(arr, 1);
    return finalArr;
};
— ウリエルツェン
ソース
パフォーマンス比較を追加しましたstackoverflow.com/a/37580979/1647737-気軽に更新してください。
— le_m
0

JavaScriptで配列を置換する方法を説明する投稿を書きました。これを行うコードは次のとおりです。

var count=0;
function permute(pre,cur){ 
    var len=cur.length;
    for(var i=0;i<len;i++){
        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++;
        }
    }
}
function print(arr){
    var len=arr.length;
    for(var i=0;i<len;i++){
        document.write(arr[i]+" ");
    }
    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++){
        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++){
        a.push(arr[i]);
    }
    return a;
}

電話するだけ

permute（[]、[1、2、3、4]）

動作します。これがどのように機能するかの詳細については、その投稿の説明を参照してください。

— PixelsTech
ソース
0 
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);
    }, []);
}
— ヨナ
ソース
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.