JavaScriptの複数配列のデカルト積


110

JavaScriptで複数の配列のデカルト積をどのように実装しますか?

例として、

cartesian([1, 2], [10, 20], [100, 200, 300]) 

戻るはずです

[
  [1, 10, 100],
  [1, 10, 200],
  [1, 10, 300],
  [2, 10, 100],
  [2, 10, 200]
  ...
]


3
これはjs-combinatoricsモジュールに実装されています:github.com/dankogai/js-combinatorics
Segal-Halevi


私はunderscore.jsについて同意するが、私は確かに私は関数型プログラミングのタグを削除すると@le_mを助ける方法を見ていないよ
viebel

Fwiw、d3 d3.cross(a, b[, reducer])は2月に追加されました。github.com/d3/d3-array#cross
Toph

回答:


105

2017年更新:バニラJSによる2行回答

ここでの回答はすべて非常に複雑です。ほとんどの回答は20行以上のコードを必要とします。

この例では、2行のバニラJavaScriptのみを使用し、lodash、アンダースコア、その他のライブラリは使用していません。

let f = (a, b) => [].concat(...a.map(a => b.map(b => [].concat(a, b))));
let cartesian = (a, b, ...c) => b ? cartesian(f(a, b), ...c) : a;

更新:

これは上記と同じですが、Airbnb JavaScriptスタイルガイドに厳密に準拠するように改善されています。eslint-config-airbnb-baseESLintを使用して検証されています

const f = (a, b) => [].concat(...a.map(d => b.map(e => [].concat(d, e))));
const cartesian = (a, b, ...c) => (b ? cartesian(f(a, b), ...c) : a);

元のコードのリンター問題について教えてくれたZuBBに特に感謝します。

これはあなたの質問からの正確な例です:

let output = cartesian([1,2],[10,20],[100,200,300]);

出力

これはそのコマンドの出力です:

[ [ 1, 10, 100 ],
  [ 1, 10, 200 ],
  [ 1, 10, 300 ],
  [ 1, 20, 100 ],
  [ 1, 20, 200 ],
  [ 1, 20, 300 ],
  [ 2, 10, 100 ],
  [ 2, 10, 200 ],
  [ 2, 10, 300 ],
  [ 2, 20, 100 ],
  [ 2, 20, 200 ],
  [ 2, 20, 300 ] ]

デモ

デモを見る:

構文

ここで使用した構文は新しいものではありません。私の例では、spreadオペレーターと残りのパラメーター(2015年6月に発行され、以前に開発された、ES6またはES2015として知られる)のECMA-262標準の第6版で定義されたJavaScriptの機能を使用します。見る:

これは、このようなコードを非常に単純にするので、使用しないのは罪です。ネイティブでサポートしていない古いプラットフォームの場合、いつでもBabelまたは他のツールを使用して古い構文にトランスパイルできます。実際、Babelによってトランスパイルされた私の例は、ここにあるほとんどの例よりも短くて簡単ですが、実際にはそうではありません。トランスパイレーションの出力は、理解または維持する必要があるものではないため、本当に重要です。それは、私が興味深いと思った事実にすぎません。

結論

2行のバニラJavaScriptで簡単に作業を完了できるので、維持するのが難しい数百行のコードを記述する必要はなく、そのような単純なことのためにライブラリ全体を使用する必要もありません。ご覧のように、言語の最新機能を使用することは本当に効果的であり、最新機能のネイティブサポートなしで古いプラットフォームをサポートする必要がある場合は、いつでもBabelまたは他のツールを使用して新しい構文を古いものに変換できます。 。

1995年のようにコーディングしないでください

JavaScriptは進化し、それには理由があります。TC39は新しい機能を追加することで言語設計の素晴らしい仕事をし、ブラウザーベンダーはそれらの機能を実装する素晴らしい仕事をします。

ブラウザの特定の機能のネイティブサポートの現在の状態を確認するには、以下を参照してください。

Nodeバージョンでのサポートを確認するには、以下を参照してください。

ネイティブでサポートしていないプラットフォームで最新の構文を使用するには、Babelを使用します。


typescriptが配列の分散を行う方法を説明するために若干の変更を加えたtypescriptバージョンを次に示します。gist.github.com/ssippe/1f92625532eef28be6974f898efb23ef
Sam Sippe

1
@rspは本当に良い答えをたくさんありがとう。シャドウされた変数(2つのローカル変数aと2つのローカル変数b)の警告のリグを取得するために少し改善するようにお願いしたいのですが
ZuBB

7
「1995年のようにコーディングしないでください」-不愉快である必要はありません。誰もがまだ追いついているわけではありません。
Godwhacker 2017

7
これは問題ありませんが、フィードすると失敗し、結果として['a', 'b'], [1,2], [[9], [10]]生成さ[ [ 'a', 1, 9 ], [ 'a', 1, 10 ], [ 'a', 2, 9 ], [ 'a', 2, 10 ], [ 'b', 1, 9 ], [ 'b', 1, 10 ], [ 'b', 2, 9 ], [ 'b', 2, 10 ] ]れます。のアイテムのタイプを保持しないことを意味します[[9], [10]]
Redu、

1
...既に使っているので、[].concat(...[array])単純になってはいけません[...array]か?
LazarLjubenović18年

88

ここで問題に機能液である(どのなし変更可能な変数は、使用して!)reduceflattenにより提供されます、underscore.js

function cartesianProductOf() {
    return _.reduce(arguments, function(a, b) {
        return _.flatten(_.map(a, function(x) {
            return _.map(b, function(y) {
                return x.concat([y]);
            });
        }), true);
    }, [ [] ]);
}

// [[1,3,"a"],[1,3,"b"],[1,4,"a"],[1,4,"b"],[2,3,"a"],[2,3,"b"],[2,4,"a"],[2,4,"b"]]
console.log(cartesianProductOf([1, 2], [3, 4], ['a']));  
<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.9.1/underscore.js"></script>

備考:このソリューションはhttp://cwestblog.com/2011/05/02/cartesian-product-of-multiple-arrays/から着想を得ています


この回答にはタイプミスがあります。「、本当」はありません(おそらく、この投稿を行ってからロダッシュは変更されていますか?)
Chris Jefferson

@ChrisJeffersonの2番目のパラメーターはflatten、平坦化を浅くすることです。ここでは必須です!
viebel、2015年

4
申し訳ありませんが、これはロダッシュ/アンダースコアの非互換性であり、フラグを交換しました。
クリスジェファーソン

1
したがって、平坦化する場合はtrueアンダースコアを使用falseし、lodashを使用して、平坦化を浅くします。
AkseliPalén15年

配列の配列を受け入れるように、この関数をどのように変更しますか?

44

ライブラリを使用せずに、プレーンなJavascriptで@viebelのコードを変更したバージョンを次に示します。

function cartesianProduct(arr) {
    return arr.reduce(function(a,b){
        return a.map(function(x){
            return b.map(function(y){
                return x.concat([y]);
            })
        }).reduce(function(a,b){ return a.concat(b) },[])
    }, [[]])
}

var a = cartesianProduct([[1, 2,3], [4, 5,6], [7, 8], [9,10]]);
console.log(JSON.stringify(a));


2
cartesianProduct([[[1]、[2]、[3]]、['a'、 'b']、[['gamma']、[['alpha']]]、['zii'、 'faa']])['gamma']を 'gamma'に、[['alpha']]を['alpha']に
平坦化するため

理由.concat(y)の代わりに.concat([ y ])
ありがとうございます

@Thankyouあなたはコメントする代わりに直接回答を編集することができます、ただそれをやっただけなので今は必要ありません:P
Olivier Lalonde

28

コミュニティはこれを些細なこと、またはリファレンス実装を見つけるのが簡単だと思っているようです。簡単な検査では、できなかったか、多分それはあなたの幸運な日のいずれかの方法で、ホイールを再発明したり、教室のようなプログラミングの問題を解決したりすることです:

function cartProd(paramArray) {

  function addTo(curr, args) {

    var i, copy, 
        rest = args.slice(1),
        last = !rest.length,
        result = [];

    for (i = 0; i < args[0].length; i++) {

      copy = curr.slice();
      copy.push(args[0][i]);

      if (last) {
        result.push(copy);

      } else {
        result = result.concat(addTo(copy, rest));
      }
    }

    return result;
  }


  return addTo([], Array.prototype.slice.call(arguments));
}


>> console.log(cartProd([1,2], [10,20], [100,200,300]));
>> [
     [1, 10, 100], [1, 10, 200], [1, 10, 300], [1, 20, 100], 
     [1, 20, 200], [1, 20, 300], [2, 10, 100], [2, 10, 200], 
     [2, 10, 300], [2, 20, 100], [2, 20, 200], [2, 20, 300]
   ]

比較的効率的な完全なリファレンス実装... :-D

効率について:ifをループから外し、2つの別々のループを持つことで技術的に一定であり、分岐予測とそのすべての混乱を助けることになるかもしれませんが、その点はJavaScriptの一種のモットーです

誰でも、-ckをお楽しみください


1
詳細な回答をありがとう@ckoz なぜreduce配列の関数を使わないのですか?
viebel 2012

1
@viebelなぜ削減を使用するのですか?一例として、reduceは古いブラウザーのサポートが非常に貧弱であり(developer.mozilla.org/en-US/docs/JavaScript/Reference/…を参照)、いずれにしても、他の回答のクレイジーなコードは実際には読みやすいように見えます?それは私にはしません。短い方がいいですが、このコードを縮小すると、同じ長さになり、デバッグ/最適化が容易になります。次に、これらのすべての「削減」ソリューションは、クロージャルックアップ(理論的には遅い)を除いて、同じものに分解され、さらに困難になります。無限セットを処理するように設計する...
ckozl

5
私は2倍高速で(imo)よりクリーンなバージョンを作成しました:pastebin.com/YbhqZuf7を使用しないことresult = result.concat(...)と使用しないことでスピードブーストを実現しargs.slice(1)ます。残念ながら、私はそれを取り除く方法curr.slice()と再帰を見つけることができませんでした。
Pauan

2
@Pauanのすばらしい仕事、私が見ているものに基づいて10%-50%のパフォーマンス向上のリーグでの全体としてのホットスポットの素晴らしい削減。「清潔さ」についてはお話しできませんが、クロージャスコープ変数を使用しているため、実際にはバージョンの追跡が難しいようです。しかし、一般的に言えば、パフォーマンスの高いコードほど、追跡が難しくなります。私は読みやすさのためにオリジナルバージョンを作成しました。パフォーマンススローダウンに参加できるように、もう少し時間があればいいのですが;)おそらく後で...
ckozl

これは本当にこれらの問題の1つです
James

26

以下の効率的な発電機の機能は、すべての与えられたのデカルト積を返す反復可能オブジェクトを

// Generate cartesian product of given iterables:
function* cartesian(head, ...tail) {
  const remainder = tail.length > 0 ? cartesian(...tail) : [[]];
  for (let r of remainder) for (let h of head) yield [h, ...r];
}

// Example:
console.log(...cartesian([1, 2], [10, 20], [100, 200, 300]));

配列、文字列、セット、および反復可能なプロトコルを実装するその他すべてのオブジェクトを受け入れます。

生成されるn-aryデカルト積の仕様に従って

  • []1つ以上の指定されたイテラブルが空の場合、[]または''
  • [[a]]単一の値を含む単一のイテラブルaが指定されている場合。

他のすべてのケースは、以下のテストケースで示されているように期待どおりに処理されます。


これで何が起こっているのか説明してくれませんか?どうもありがとう!
LeandroP

ジェネレーター関数+末尾再帰+ 2層ループを使用する素晴らしい例を教えてくれてありがとう!ただし、コード内の最初のforループの位置を変更して、出力サブ配列の順序を正しくする必要があります。修正されたコード:function* cartesian(head, ...tail) { for (let h of head) { const remainder = tail.length > 0 ? cartesian(...tail) : [[]]; for (let r of remainder) yield [h, ...r] } }
ooo

@ooo OPのコメントで指定されたデカルト積タプルの順序を再現したい場合、変更は正しいです。ただし、製品内のタプルの順序は通常関係ありません。例えば、数学的には結果は順序付けられていないセットです。この順序を選択したのは、再帰呼び出しがはるかに少なくて済むため、パフォーマンスが少し高いためです。ただし、ベンチマークは実行しませんでした。
le_m

正誤表:上記の私のコメントでは、「末尾再帰」は「再帰」である必要があります(この場合、末尾呼び出しではありません)。
ooo

20

以下は、派手ではない簡単な再帰的な解決策です。

function cartesianProduct(a) { // a = array of array
    var i, j, l, m, a1, o = [];
    if (!a || a.length == 0) return a;

    a1 = a.splice(0, 1)[0]; // the first array of a
    a = cartesianProduct(a);
    for (i = 0, l = a1.length; i < l; i++) {
        if (a && a.length) for (j = 0, m = a.length; j < m; j++)
            o.push([a1[i]].concat(a[j]));
        else
            o.push([a1[i]]);
    }
    return o;
}

console.log(cartesianProduct([[1,2], [10,20], [100,200,300]]));
// [[1,10,100],[1,10,200],[1,10,300],[1,20,100],[1,20,200],[1,20,300],[2,10,100],[2,10,200],[2,10,300],[2,20,100],[2,20,200],[2,20,300]]


2
これは、このトピックで最も効率的な純粋なJSコードであることがわかります。長さ1Mの配列を生成するために3 x 100の項目配列で終了するまでに約600ミリ秒かかる
Redu

1
cartesianProduct([[[1]、[2]、[3]]、['a'、 'b']、[['gamma']、[['alpha']]]、['zii'、 'faa']]); 元の値をフラット化せずに
Mzn 2017年

10

ECMAScript 2015のジェネレーター関数を使用する再帰的な方法は次のとおりので、一度にすべてのタプルを作成する必要はありません。

function* cartesian() {
    let arrays = arguments;
    function* doCartesian(i, prod) {
        if (i == arrays.length) {
            yield prod;
        } else {
            for (let j = 0; j < arrays[i].length; j++) {
                yield* doCartesian(i + 1, prod.concat([arrays[i][j]]));
            }
        }
    }
    yield* doCartesian(0, []);
}

console.log(JSON.stringify(Array.from(cartesian([1,2],[10,20],[100,200,300]))));
console.log(JSON.stringify(Array.from(cartesian([[1],[2]],[10,20],[100,200,300]))));


これは、配列の1つに次のような配列項目がある場合は機能しませんcartesian([[1],[2]],[10,20],[100,200,300])
Redu

@Redu Answerが配列引数をサポートするように更新されました。
heenenee 2016年

はい、.concat()組み込みのスプレッドオペレーターは、時々、だまされる可能性があります。
Redu、

10

これは、ネイティブES2019を使用したワンライナーですflatMap。ライブラリは必要ありません。最新のブラウザー(またはトランスパイラー)のみです。

data.reduce((a, b) => a.flatMap(x => b.map(y => [...x, y])), [[]]);

これは本質的に、lodashなしのviebelの回答の最新バージョンです。


9

ES6ジェネレーターで一般的なバックトラッキングを使用すると、

function cartesianProduct(...arrays) {
  let current = new Array(arrays.length);
  return (function* backtracking(index) {
    if(index == arrays.length) yield current.slice();
    else for(let num of arrays[index]) {
      current[index] = num;
      yield* backtracking(index+1);
    }
  })(0);
}
for (let item of cartesianProduct([1,2],[10,20],[100,200,300])) {
  console.log('[' + item.join(', ') + ']');
}
div.as-console-wrapper { max-height: 100%; }

以下に、古いブラウザと互換性のある同様のバージョンがあります。


9

これは、矢印関数を使用した純粋なES6ソリューションです。

function cartesianProduct(arr) {
  return arr.reduce((a, b) =>
    a.map(x => b.map(y => x.concat(y)))
    .reduce((a, b) => a.concat(b), []), [[]]);
}

var arr = [[1, 2], [10, 20], [100, 200, 300]];
console.log(JSON.stringify(cartesianProduct(arr)));


7

lodashを使ったcoffeescriptバージョン:

_ = require("lodash")
cartesianProduct = ->
    return _.reduceRight(arguments, (a,b) ->
        _.flatten(_.map(a,(x) -> _.map b, (y) -> x.concat(y)), true)
    , [ [] ])

7

インデントで読みやすくするための単一行アプローチ。

result = data.reduce(
    (a, b) => a.reduce(
        (r, v) => r.concat(b.map(w => [].concat(v, w))),
        []
    )
);

必要なデカルトアイテムの配列を含む単一の配列を取ります。

var data = [[1, 2], [10, 20], [100, 200, 300]],
    result = data.reduce((a, b) => a.reduce((r, v) => r.concat(b.map(w => [].concat(v, w))), []));

console.log(result.map(a => a.join(' ')));
.as-console-wrapper { max-height: 100% !important; top: 0; }


私は正しく配列は、単一の要素を持っている場合に対処するために、ガード文を追加する必要がありました:if (arr.length === 1) return arr[0].map(el => [el]);
JacobEvelyn

5

これはタグ付けされた関数型プログラミングなので、Listモナドを見てみましょう:

このモナディックリストの1つのアプリケーションは、非決定論的な計算を表すことです。アルゴリズムのList すべての実行パスの結果を保持できます...

まあそれはのための完全な適合のように聞こえcartesianます。JavaScriptは私たちに与えArray、モナディックバインディング関数はArray.prototype.flatMapなので、それらを使用してみましょう-

const cartesian = (...all) =>
{ const loop = (t, a, ...more) =>
    a === undefined
      ? [ t ]
      : a .flatMap (x => loop ([ ...t, x ], ...more))
  return loop ([], ...all)
}

console .log (cartesian ([1,2], [10,20], [100,200,300]))

loop上記の代わりにt、カレーパラメータとして追加できます-

const makeCartesian = (t = []) => (a, ...more) =>
  a === undefined
    ? [ t ]
    : a .flatMap (x => makeCartesian ([ ...t, x ]) (...more))

const cartesian =
  makeCartesian ()

console .log (cartesian ([1,2], [10,20], [100,200,300]))


3

このトピックの回答のいくつかは、入力配列のいずれかに配列項目が含まれていると失敗します。あなたはそれをよりよくチェックするべきです。

とにかく、アンダースコアは必要ありません。私はこれが純粋なJS ES6でそれをできる限り機能的にするべきだと思います。

このコードでは、reduceとネストされたマップを使用して、2つの配列のデカルト積を取得していますが、2番目の配列は、1つ少ない配列で同じ関数を再帰的に呼び出しています。したがって.. a[0].cartesian(...a.slice(1))

Array.prototype.cartesian = function(...a){
  return a.length ? this.reduce((p,c) => (p.push(...a[0].cartesian(...a.slice(1)).map(e => a.length > 1 ? [c,...e] : [c,e])),p),[])
                  : this;
};

var arr = ['a', 'b', 'c'],
    brr = [1,2,3],
    crr = [[9],[8],[7]];
console.log(JSON.stringify(arr.cartesian(brr,crr))); 


3

私の特定の設定では、「昔ながらの」アプローチは、より近代的な機能に基づく方法よりも効率的であるように思われました。以下は、他のユーザーにも役立つコード(このスレッドに@rspおよび@sebnukemが投稿した他のソリューションとの小さな比較を含む)です。

アイデアは以下の通りです。それぞれがコンポーネントを持つN配列の外積を構築しているとしましょう。これらの配列の外積には要素があり、要素を正の整数である次元ベクトルで各要素を識別でき、-番目の要素は上からによって厳密に制限されます。たとえば、ベクトルは、各配列から最初の要素を取得する特定の組み合わせに対応しますが、各配列から最後の要素を取得する組み合わせで識別されます。したがって、すべてを構築するためにa_1,...,a_Nm_iM=m_1*m_2*...*m_NN-im_i(0, 0, ..., 0)(m_1-1, m_2-1, ..., m_N-1)M 組み合わせでは、以下の関数がそのようなすべてのベクトルを連続的に構築し、それらのそれぞれについて、入力配列の要素の対応する組み合わせを識別します。

function cartesianProduct(){
    const N = arguments.length;

    var arr_lengths = Array(N);
    var digits = Array(N);
    var num_tot = 1;
    for(var i = 0; i < N; ++i){
        const len = arguments[i].length;
        if(!len){
            num_tot = 0;
            break;
        }
        digits[i] = 0;
        num_tot *= (arr_lengths[i] = len);
    }

    var ret = Array(num_tot);
    for(var num = 0; num < num_tot; ++num){

        var item = Array(N);
        for(var j = 0; j < N; ++j){ item[j] = arguments[j][digits[j]]; }
        ret[num] = item;

        for(var idx = 0; idx < N; ++idx){
            if(digits[idx] == arr_lengths[idx]-1){
                digits[idx] = 0;
            }else{
                digits[idx] += 1;
                break;
            }
        }
    }
    return ret;
}
//------------------------------------------------------------------------------
let _f = (a, b) => [].concat(...a.map(a => b.map(b => [].concat(a, b))));
let cartesianProduct_rsp = (a, b, ...c) => b ? cartesianProduct_rsp(_f(a, b), ...c) : a;
//------------------------------------------------------------------------------
function cartesianProduct_sebnukem(a) {
    var i, j, l, m, a1, o = [];
    if (!a || a.length == 0) return a;

    a1 = a.splice(0, 1)[0];
    a = cartesianProduct_sebnukem(a);
    for (i = 0, l = a1.length; i < l; i++) {
        if (a && a.length) for (j = 0, m = a.length; j < m; j++)
            o.push([a1[i]].concat(a[j]));
        else
            o.push([a1[i]]);
    }
    return o;
}
//------------------------------------------------------------------------------
const L = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
const args = [L, L, L, L, L, L];

let fns = {
    'cartesianProduct': function(args){ return cartesianProduct(...args); },
    'cartesianProduct_rsp': function(args){ return cartesianProduct_rsp(...args); },
    'cartesianProduct_sebnukem': function(args){ return cartesianProduct_sebnukem(args); }
};

Object.keys(fns).forEach(fname => {
    console.time(fname);
    const ret = fns[fname](args);
    console.timeEnd(fname);
});

node v6.12.2、私は次のタイミングを取得します:

cartesianProduct: 427.378ms
cartesianProduct_rsp: 1710.829ms
cartesianProduct_sebnukem: 593.351ms

3

TypeScriptが必要な場合(@Dannyの回答を再実装)

/**
 * Calculates "Cartesian Product" sets.
 * @example
 *   cartesianProduct([[1,2], [4,8], [16,32]])
 *   Returns:
 *   [
 *     [1, 4, 16],
 *     [1, 4, 32],
 *     [1, 8, 16],
 *     [1, 8, 32],
 *     [2, 4, 16],
 *     [2, 4, 32],
 *     [2, 8, 16],
 *     [2, 8, 32]
 *   ]
 * @see https://stackoverflow.com/a/36234242/1955709
 * @see https://en.wikipedia.org/wiki/Cartesian_product
 * @param arr {T[][]}
 * @returns {T[][]}
 */
function cartesianProduct<T> (arr: T[][]): T[][] {
  return arr.reduce((a, b) => {
    return a.map(x => {
      return b.map(y => {
        return x.concat(y)
      })
    }).reduce((c, d) => c.concat(d), [])
  }, [[]] as T[][])
}

2

選択のために、配列を使用した実際の単純な実装reduce

const array1 = ["day", "month", "year", "time"];
const array2 = ["from", "to"];
const process = (one, two) => [one, two].join(" ");

const product = array1.reduce((result, one) => result.concat(array2.map(two => process(one, two))), []);

2

ほんの数行で最新のJavaScript。Lodashのような外部ライブラリや依存関係はありません。

function cartesian(...arrays) {
  return arrays.reduce((a, b) => a.flatMap(x => b.map(y => x.concat([y]))), [ [] ]);
}

console.log(
  cartesian([1, 2], [10, 20], [100, 200, 300])
    .map(arr => JSON.stringify(arr))
    .join('\n')
);


2

あなたreduceは2D配列でした。flatMapアキュムレータ配列で使用してacc.length x curr.length、各ループの組み合わせの数を取得します。[].concat(c, n)が使用されるのcは、が最初の反復の数値であり、その後に配列が使用されるためです。

const data = [ [1, 2], [10, 20], [100, 200, 300] ];

const output = data.reduce((acc, curr) =>
  acc.flatMap(c => curr.map(n => [].concat(c, n)))
)

console.log(JSON.stringify(output))

(これはニーナ・ショルツの答えに基づいています


1

製品を実際に結果セットに追加する前に製品をフィルタリングおよび変更する機能を追加する非再帰的アプローチ。.forEachではなく.mapを使用していることに注意してください。一部のブラウザでは、.mapがより高速に実行されます。

function crossproduct(arrays,rowtest,rowaction) {
      // Calculate the number of elements needed in the result
      var result_elems = 1, row_size = arrays.length;
      arrays.map(function(array) {
            result_elems *= array.length;
      });
      var temp = new Array(result_elems), result = [];

      // Go through each array and add the appropriate element to each element of the temp
      var scale_factor = result_elems;
      arrays.map(function(array)
      {
        var set_elems = array.length;
        scale_factor /= set_elems;
        for(var i=result_elems-1;i>=0;i--) {
            temp[i] = (temp[i] ? temp[i] : []);
            var pos = i / scale_factor % set_elems;
            // deal with floating point results for indexes, this took a little experimenting
            if(pos < 1 || pos % 1 <= .5) {
                pos = Math.floor(pos);
            } else {
                pos = Math.min(array.length-1,Math.ceil(pos));
            }
            temp[i].push(array[pos]);
            if(temp[i].length===row_size) {
                var pass = (rowtest ? rowtest(temp[i]) : true);
                if(pass) {
                    if(rowaction) {
                        result.push(rowaction(temp[i]));
                    } else {
                        result.push(temp[i]);
                    }
                }
            }
        }
      });
      return result;
    }

1

シンプルな「心と視覚に優しい」ソリューション。

ここに画像の説明を入力してください


// t = [i, length]

const moveThreadForwardAt = (t, tCursor) => {
  if (tCursor < 0)
    return true; // reached end of first array

  const newIndex = (t[tCursor][0] + 1) % t[tCursor][1];
  t[tCursor][0] = newIndex;

  if (newIndex == 0)
    return moveThreadForwardAt(t, tCursor - 1);

  return false;
}

const cartesianMult = (...args) => {
  let result = [];
  const t = Array.from(Array(args.length)).map((x, i) => [0, args[i].length]);
  let reachedEndOfFirstArray = false;

  while (false == reachedEndOfFirstArray) {
    result.push(t.map((v, i) => args[i][v[0]]));

    reachedEndOfFirstArray = moveThreadForwardAt(t, args.length - 1);
  }

  return result;
}

// cartesianMult(
//   ['a1', 'b1', 'c1'],
//   ['a2', 'b2'],
//   ['a3', 'b3', 'c3'],
//   ['a4', 'b4']
// );

console.log(cartesianMult(
  ['a1'],
  ['a2', 'b2'],
  ['a3', 'b3']
));

1

プレーンなJavaScriptでの@viebelのコードの単純な修正バージョン:

function cartesianProduct(...arrays) {
  return arrays.reduce((a, b) => {
    return [].concat(...a.map(x => {
      const next = Array.isArray(x) ? x : [x];
      return [].concat(b.map(y => next.concat(...[y])));
    }));
  });
}

const product = cartesianProduct([1, 2], [10, 20], [100, 200, 300]);

console.log(product);
/*
[ [ 1, 10, 100 ],
  [ 1, 10, 200 ],
  [ 1, 10, 300 ],
  [ 1, 20, 100 ],
  [ 1, 20, 200 ],
  [ 1, 20, 300 ],
  [ 2, 10, 100 ],
  [ 2, 10, 200 ],
  [ 2, 10, 300 ],
  [ 2, 20, 100 ],
  [ 2, 20, 200 ],
  [ 2, 20, 300 ] ];
*/

1

より読みやすい実装

function productOfTwo(one, two) {
  return one.flatMap(x => two.map(y => [].concat(x, y)));
}

function product(head = [], ...tail) {
  if (tail.length === 0) return head;
  return productOfTwo(head, product(...tail));
}

const test = product(
  [1, 2, 3],
  ['a', 'b']
);

console.log(JSON.stringify(test));


1
f=(a,b,c)=>a.flatMap(ai=>b.flatMap(bi=>c.map(ci=>[ai,bi,ci])))

これは3つのアレイ用です。
いくつかの回答は、任意の数の配列に対して方法を提供しました。
これにより、アレイを簡単に縮小または拡張できます。
1つのセットと繰り返しの組み合わせが必要だったので、次のように使用できました。

f(a,a,a)

しかし使用:

f=(a,b,c)=>a.flatMap(a1=>a.flatMap(a2=>a.map(a3=>[a1,a2,a3])))

0

関数を渡して各組み合わせを処理できるソリューションを誰も投稿していないことに気付いたので、これが私のソリューションです:

const _ = require('lodash')

function combinations(arr, f, xArr = []) {
    return arr.length>1 
    ? _.flatMap(arr[0], x => combinations(arr.slice(1), f, xArr.concat(x)))
    : arr[0].map(x => f(...xArr.concat(x)))
}

// use case
const greetings = ["Hello", "Goodbye"]
const places = ["World", "Planet"]
const punctuationMarks = ["!", "?"]
combinations([greetings,places,punctuationMarks], (greeting, place, punctuationMark) => `${greeting} ${place}${punctuationMark}`)
  .forEach(row => console.log(row))

出力:

Hello World!
Hello World?
Hello Planet!
Hello Planet?
Goodbye World!
Goodbye World?
Goodbye Planet!
Goodbye Planet?

0

配列の配列を入力として取るプレーンなJSブルートフォースアプローチ。

var cartesian = function(arrays) {
    var product = [];
    var precals = [];
    var length = arrays.reduce(function(acc, curr) {
        return acc * curr.length
    }, 1);
    for (var i = 0; i < arrays.length; i++) {
        var array = arrays[i];
        var mod = array.length;
        var div = i > 0 ? precals[i - 1].div * precals[i - 1].mod : 1;
        precals.push({
            div: div,
            mod: mod
        });
    }
    for (var j = 0; j < length; j++) {
        var item = [];
        for (var i = 0; i < arrays.length; i++) {
            var array = arrays[i];
            var precal = precals[i];
            var k = (~~(j / precal.div)) % precal.mod;
            item.push(array[k]);
        }
        product.push(item);
    }
    return product;
};

cartesian([
    [1],
    [2, 3]
]);

cartesian([
    [1],
    [2, 3],
    [4, 5, 6]
]);

0

var chars = ['A', 'B', 'C']
var nums = [1, 2, 3]

var cartesianProduct = function() {
  return _.reduce(arguments, function(a, b) {
    return _.flatten(_.map(a, function(x) {
      return _.map(b, function(y) {
        return x.concat(y);
      });
    }), true);
  }, [
    []
  ]);
};

console.log(cartesianProduct(chars, nums))
<script src="https://cdnjs.cloudflare.com/ajax/libs/underscore.js/1.8.3/underscore-min.js"></script>

@dummerslの回答をCoffeScriptからJavaScriptに変換しました。うまくいきます。

var chars = ['A', 'B', 'C']
var nums = [1, 2, 3]

var cartesianProduct = function() {
  return _.reduce(arguments, function(a, b) {
    return _.flatten(_.map(a, function(x) {
      return _.map(b, function(y) {
        return x.concat(y);
      });
    }), true);
  }, [[]]);
};

console.log( cartesianProduct(chars, nums) )

0

さらに別の実装。最短でも派手でもないが速い:

function cartesianProduct() {
    var arr = [].slice.call(arguments),
        intLength = arr.length,
        arrHelper = [1],
        arrToReturn = [];

    for (var i = arr.length - 1; i >= 0; i--) {
        arrHelper.unshift(arrHelper[0] * arr[i].length);
    }

    for (var i = 0, l = arrHelper[0]; i < l; i++) {
        arrToReturn.push([]);
        for (var j = 0; j < intLength; j++) {
            arrToReturn[i].push(arr[j][(i / arrHelper[j + 1] | 0) % arr[j].length]);
        }
    }

    return arrToReturn;
}

0

ライブラリは必要ありません!:)

矢印関数が必要ですが、おそらくそれほど効率的ではありません。:/

const flatten = (xs) => 
    xs.flat(Infinity)

const binaryCartesianProduct = (xs, ys) =>
    xs.map((xi) => ys.map((yi) => [xi, yi])).flat()

const cartesianProduct = (...xss) =>
    xss.reduce(binaryCartesianProduct, [[]]).map(flatten)
      
console.log(cartesianProduct([1,2,3], [1,2,3], [1,2,3]))


0

記録のために

ここでそれは私のバージョンになります。最も単純なJavaScriptイテレータ「for()」を使用して作成したため、すべてのケースで互換性があり、最高のパフォーマンスが得られます。

function cartesian(arrays){
    var quant = 1, counters = [], retArr = [];

    // Counts total possibilities and build the counters Array;
    for(var i=0;i<arrays.length;i++){
        counters[i] = 0;
        quant *= arrays[i].length;
    }

    // iterate all possibilities
    for(var i=0,nRow;i<quant;i++){
        nRow = [];
        for(var j=0;j<counters.length;j++){
            if(counters[j] < arrays[j].length){
                nRow.push(arrays[j][counters[j]]);
            } else { // in case there is no such an element it restarts the current counter
                counters[j] = 0;
                nRow.push(arrays[j][counters[j]]);
            }
            counters[j]++;
        }
        retArr.push(nRow);
    }
    return retArr;
}

宜しくお願いします。

弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.