インターリーブされたシーケンスは、いくつかのシーケンスの任意のマージを表します。

インターリーブシーケンスは、いくつかのリストから1つずつリストに要素を追加し、そのたびにリストから次の要素を選択することで作成できます。したがって、インターリーブシーケンスには、すべてのリストと一貫した順序で、結合されたすべてのリストのまったく同じ要素が含まれます。

1つのリストのインターリーブは、同じリストのみです。

チャレンジ

あなたの課題は、任意の数のシーケンスを取り、それらのシーケンスのすべての可能なインターリーブを出力する関数/プログラムを作成することです。

例

Input: [1, 2], [3, 4]
Output:
    [1, 2, 3, 4]
    [1, 3, 2, 4]
    [1, 3, 4, 2] 
    [3, 1, 2, 4]
    [3, 1, 4, 2]
    [3, 4, 1, 2]

Input: [1, 2, 3, 4, 5]
Output:
    [1, 2, 3, 4, 5]

Input: []
Output:
    []

Input: <nothing>
Output:
    []

(also acceptable)
Input: <nothing>
Output: <nothing>

Input: [1, 2, 3], [4, 5]
Output:
    [1, 2, 3, 4, 5]
    [1, 2, 4, 3, 5]
    [1, 2, 4, 5, 3]
    [1, 4, 2, 3, 5]
    [1, 4, 2, 5, 3]
    [1, 4, 5, 2, 3]
    [4, 1, 2, 3, 5]
    [4, 1, 2, 5, 3]
    [4, 1, 5, 2, 3]
    [4, 5, 1, 2, 3]

Input: [1, 2], [3, 4], [5, 6]
Output:
    [1, 2, 3, 4, 5, 6]
    [1, 2, 3, 5, 4, 6]
    [1, 2, 3, 5, 6, 4]
    [1, 2, 5, 3, 4, 6]
    [1, 2, 5, 3, 6, 4]
    [1, 2, 5, 6, 3, 4]
    [1, 3, 2, 4, 5, 6]
    [1, 3, 2, 5, 4, 6]
    [1, 3, 2, 5, 6, 4]
    [1, 3, 4, 2, 5, 6]
    [1, 3, 4, 5, 2, 6]
    [1, 3, 4, 5, 6, 2]
    [1, 3, 5, 2, 4, 6]
    [1, 3, 5, 2, 6, 4]
    [1, 3, 5, 4, 2, 6]
    [1, 3, 5, 4, 6, 2]
    [1, 3, 5, 6, 2, 4]
    [1, 3, 5, 6, 4, 2]
    [1, 5, 2, 3, 4, 6]
    [1, 5, 2, 3, 6, 4]
    [1, 5, 2, 6, 3, 4]
    [1, 5, 3, 2, 4, 6]
    [1, 5, 3, 2, 6, 4]
    [1, 5, 3, 4, 2, 6]
    [1, 5, 3, 4, 6, 2]
    [1, 5, 3, 6, 2, 4]
    [1, 5, 3, 6, 4, 2]
    [1, 5, 6, 2, 3, 4]
    [1, 5, 6, 3, 2, 4]
    [1, 5, 6, 3, 4, 2]
    [3, 1, 2, 4, 5, 6]
    [3, 1, 2, 5, 4, 6]
    [3, 1, 2, 5, 6, 4]
    [3, 1, 4, 2, 5, 6]
    [3, 1, 4, 5, 2, 6]
    [3, 1, 4, 5, 6, 2]
    [3, 1, 5, 2, 4, 6]
    [3, 1, 5, 2, 6, 4]
    [3, 1, 5, 4, 2, 6]
    [3, 1, 5, 4, 6, 2]
    [3, 1, 5, 6, 2, 4]
    [3, 1, 5, 6, 4, 2]
    [3, 4, 1, 2, 5, 6]
    [3, 4, 1, 5, 2, 6]
    [3, 4, 1, 5, 6, 2]
    [3, 4, 5, 1, 2, 6]
    [3, 4, 5, 1, 6, 2]
    [3, 4, 5, 6, 1, 2]
    [3, 5, 1, 2, 4, 6]
    [3, 5, 1, 2, 6, 4]
    [3, 5, 1, 4, 2, 6]
    [3, 5, 1, 4, 6, 2]
    [3, 5, 1, 6, 2, 4]
    [3, 5, 1, 6, 4, 2]
    [3, 5, 4, 1, 2, 6]
    [3, 5, 4, 1, 6, 2]
    [3, 5, 4, 6, 1, 2]
    [3, 5, 6, 1, 2, 4]
    [3, 5, 6, 1, 4, 2]
    [3, 5, 6, 4, 1, 2]
    [5, 1, 2, 3, 4, 6]
    [5, 1, 2, 3, 6, 4]
    [5, 1, 2, 6, 3, 4]
    [5, 1, 3, 2, 4, 6]
    [5, 1, 3, 2, 6, 4]
    [5, 1, 3, 4, 2, 6]
    [5, 1, 3, 4, 6, 2]
    [5, 1, 3, 6, 2, 4]
    [5, 1, 3, 6, 4, 2]
    [5, 1, 6, 2, 3, 4]
    [5, 1, 6, 3, 2, 4]
    [5, 1, 6, 3, 4, 2]
    [5, 3, 1, 2, 4, 6]
    [5, 3, 1, 2, 6, 4]
    [5, 3, 1, 4, 2, 6]
    [5, 3, 1, 4, 6, 2]
    [5, 3, 1, 6, 2, 4]
    [5, 3, 1, 6, 4, 2]
    [5, 3, 4, 1, 2, 6]
    [5, 3, 4, 1, 6, 2]
    [5, 3, 4, 6, 1, 2]
    [5, 3, 6, 1, 2, 4]
    [5, 3, 6, 1, 4, 2]
    [5, 3, 6, 4, 1, 2]
    [5, 6, 1, 2, 3, 4]
    [5, 6, 1, 3, 2, 4]
    [5, 6, 1, 3, 4, 2]
    [5, 6, 3, 1, 2, 4]
    [5, 6, 3, 1, 4, 2]
    [5, 6, 3, 4, 1, 2]

ルール

• 禁止されている標準的な抜け穴（当たり前）
• 入力は、リストの開始位置と終了位置が明確である限り、リストのリスト、リストの可変引数リスト、パラメータリストなど、任意の妥当な形式で取得できます。
• リストの開始位置と終了位置が明確である限り、出力は任意の妥当な形式でかまいません。有効な出力には次のものが含まれますが、必ずしもこれらに限定されません。
  • stdout、1行に1つのリスト
  • リストのリスト
  • リストのイテレータ（言語にリストがある場合はジェネレータで実装できます）
• 生成されたインターリーブの順序は重要ではありませんが、インターリーブが繰り返されることはありません。
• 繰り返し検出を簡素化するために、すべての入力シーケンスのすべての要素が一意であると想定することができます。
• 入力としてリストが指定されていない場合、空のリストと出力は有効な出力ではありません。
• シーケンス内の要素のタイプは無関係です。（たとえば、それらはすべて1つのタイプまたはタイプのミッシュマッシュのいずれかであり、どちらかがあなたの言語でより便利である場合があります）
• プログラム/関数は、有限時間で終了することが保証されている必要があります。
• これはcode-golfであるため、各言語の最短コードが優先されます。

Haskell、84 77 76バイト

foldl((.(!)).(>>=))[[]]
a#b=(b:)<$>a
x@(a:c)!y@(b:d)=x!d#b++c!y#a
a!b=[a++b]

7バイトの@Lynnと1バイトの@ user9549915に感謝します！

オンラインでお試しください！

パイソン2、103の 92 79 78バイト

def f(A,c=[]):
 if not[f([b[b==x:]for b in A],c+x[:1])for x in A if x]:print c

オンラインでお試しください！

または：

Python 3、73バイト

def f(A,c=[]):[f([b[b==x:]for b in A],c+x[:1])for x in A if x]or print(c)

オンラインでお試しください！

-1置き換えることによって[x[0]]でx[:1]どおりXNOR

ニールの答えが示唆するように、より長いアプローチではなく、恥知らずに盗んで拡大する[b[b==x:]for b in A]ことにより、-13バイト。enumerate

リストのリストAを入力として受け取ります。のすべての要素Aが空の場合、で評価されるリストはif空になるため、再帰の終わりに到達してcanになりますprint。それ以外の場合、1つ以上Noneののリストがあります。再帰します。

ゼリー、11バイト

FŒ!fЀ⁼ṛɗÐf

オンラインでお試しください！

使い方

FŒ!fЀ⁼ṛɗÐf  Main link. Argument: A (array of arrays)

F            Flatten A.
 Œ!          Take all permutations.
        ɗÐf  Filter by the chain to the left, keeping only permutations for which
             it returns a truthy value.
   fЀ         Intersect the permutation with each array in A.
      ⁼ṛ       Test if the result is equal to A.

ルビー、66バイト

f=->a,*p{(a-=[[]])[0]?a.flat_map{|b|h,*t=b;f[a-[b]+[t],*p,h]}:[p]}

空でないシーケンスがない場合は、空のシーケンスを返します。それ以外の場合、空でないシーケンスごとに、最初の要素を削除して再帰し、各結果の先頭に追加します。実装では、要素がグローバルに一意であることが保証されているという仮定を使用します。そうしないとa-[b]、再帰呼び出しから複数のシーケンスが削除される可能性があります。リフレクションではありますが、実際には重複出力を避けるための正しい動作になるでしょう。

例IO：

f[[[1,2],[3,4]]] => [[1, 3, 2, 4], [1, 3, 4, 2], [1, 2, 3, 4], [3, 1, 4, 2], [3, 1, 2, 4], [3, 4, 1, 2]]

Wolfram言語（Mathematica）、76 75 71バイト

Cases[Permutations[Join@@#],x_/;And@@OrderedQ/@(x~Position~#&/@#&/@#)]&
(* or *)
Cases[Join/*Permutations@@#,x_/;And@@(x~Position~#&/@#&/*OrderedQ/@#)]&

オンラインでお試しください！

素朴なアプローチ：入力のインターリーブであるすべての順列を見つけます。

説明

Permutations[Join@@#]

<input>すべての順列を平らにして見つけます。

Cases[ ... ,x_/; ...]

xそのようなすべての要素を見つける...

(x~Position~#&/@#&/@#)

深さ2のすべてのアイテム<input>を、それぞれの位置に置き換えますx。

And@@OrderedQ/@ ...

すべての深さ1リストが順序付けられているかどうかを確認します（つまり、昇順）。

インターリーブの実際の実装、117バイト

Cases[{}~(f=ReplaceList[#2,{{a___,{b_,c___},d___}/;b>0:>#~Join~{b}~f~{a,{c},d},_:>#}]&)~#,{___},{Tr[1^(Join@@#)]+1}]&

オンラインでお試しください！

Pythonの2、87の 84バイト

f=lambda a:any(a)and[b[:1]+c for b in a if b for c in f([c[c==b:]for c in a])]or[[]]

オンラインでお試しください！JavaScript回答のポート。編集：@ChasBrownのおかげで3バイト保存されました。

Haskell、45バイト

f l=max[[]][h:y|h:t<-l,y<-f$t:filter(/=h:t)l]

オンラインでお試しください！

Chas BrownのPython answerから改作。

これmax[[]]は[[]]、入力に[]要素のみが含まれる場合の基本ケースを提供するトリックです。その場合、空、再帰に使用されるリストは空であり、をmax[[]][]与え[[]]ます。

再帰ではなく、選択的に選ばれたリストの最初の要素をドロップするとh:t、私たちはして新しいリストを作るt前にしてh:t除外します。

JavaScript（Firefox 30-57）、92バイト

f=a=>a.some(b=>b+b)?[for(b of a)if(b+b)for(c of f(a.map(c=>c.slice(c==b))))[b[0],...c]]:[[]]

Japt -Q、14バイト

c á f@e_XfZ eZ
c              // Flatten the input into a single array
  á            // and find all permutations.
    f          // Then filter the results for items
     @e_       // where for each original input
        XfZ eZ // the ordering of the items is unchanged.

入力を配列の配列として受け取ります。-Q出力で配列表記を保持します。

ここで試してみてください。

Scala：最小限にするためではなく、より明確な参照リソース）

object Interleave {

  private def interleavePair[A](x: Seq[A], y: Seq[A]): Seq[Seq[A]] =
    (x, y) match {
      case (a +: c, b +: d) =>
        interleavePair(x, d).map(b +: _) ++ interleavePair(c, y).map(a +: _)
      case _ => Seq(x ++ y)
    }

  def interleave[A](ssa: Seq[Seq[A]]): Seq[Seq[A]] =
    ssa.foldLeft[Seq[Seq[A]]](Seq(Seq.empty)) {
      case (sssat, sa) => sssat.flatMap(interleavePair(sa, _))
    }
}

object Main extends App {

  import Interleave._

  println(interleave(Seq()))
  println(interleave(Seq(Seq(1, 2), Seq(3, 4))))
}

オンラインでお試しください！