インターリーブシーケンス


18

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

インターリーブシーケンスは、いくつかのリストから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つのタイプまたはタイプのミッシュマッシュのいずれかであり、どちらかがあなたの言語でより便利である場合があります)
  • プログラム/関数は、有限時間で終了することが保証されている必要があります。
  • これはであるため、各言語の最短コードが優先されます。

リストなしの唯一のインターリーブは空のリストです。それは、入力としてリストが与えられないときでは[[]]なく、出力しなければならないということ[]ですか?
エリックアウトゴルファー

また、リストの長さは等しくなりますか?
エリックアウトゴルファー

入力としてリストが与えられていない場合、出力としてリストを返さないことは数学的に正気だと思います。両方を許可します。すべての出力リストは同じ長さになります。入力リストの長さは異なる場合があります。
ビーフスター

回答:



5

パイソン2103の 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ののリストがあります。再帰します。


[x[0]]あるx[:1]
XNOR

@xnor:もちろんです!THX!
チャスブラウン

4

ゼリー、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.

3

ルビー、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]]


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}]&

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


2

Pythonの287の 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バイト保存されました。


-3置き換えることによってsum(a,[])any(a)
チャスブラウン

@ChasBrownありがたいことに、私はPythonをよく知らない。
ニール

ニール:十分だと思います:)。sum(a,[])ただし、状況によってはうまく使用できます!
チャスブラウン

2

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除外します。


0

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]]:[[]]

0

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出力で配列表記を保持します。

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


0

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

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


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