Verschachtelte Sequenzen repräsentieren ein willkürliches Zusammenführen einer Anzahl von Sequenzen.

Eine verschachtelte Sequenz kann durch Anhängen von Elementen an eine Liste nacheinander aus einer bestimmten Anzahl von Listen erstellt werden, wobei jedes Mal das nächste Element aus einer bestimmten Liste ausgewählt wird. Daher enthält eine verschachtelte Sequenz genau die gleichen Elemente aller kombinierten Listen in einer Reihenfolge, die mit allen Listen übereinstimmt.

Die einzige Verschachtelung von 1 Liste ist dieselbe Liste.

Herausforderung

Ihre Herausforderung besteht darin, eine Funktion / ein Programm zu erstellen, das eine beliebige Anzahl von Sequenzen annimmt und alle möglichen Verschachtelungen dieser Sequenzen ausgibt.

Beispiele

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]

Regeln

• Standardlücken verboten (duh)
• Die Eingabe kann in jedem vernünftigen Format erfolgen, z. B. als Liste von Listen, Vararg-Liste von Listen, Parameterlisten usw., sofern eindeutig festgelegt ist, wo Listen beginnen und enden.
• Die Ausgabe kann in jedem vernünftigen Format erfolgen, sofern klar ist, wo Listen beginnen und enden. Gültige Ausgaben sind unter anderem:
  • stdout mit einer Liste pro Zeile
  • Eine Liste von Listen
  • Ein Iterator über Listen (kann mit einem Generator implementiert werden, wenn Ihre Sprache sie hat)
• Die Reihenfolge der erhaltenen Verschachtelungen spielt keine Rolle, es sollten jedoch keine wiederholten Verschachtelungen auftreten.
• Um die Wiederholungserkennung zu vereinfachen, können Sie davon ausgehen, dass alle Elemente in allen Eingabesequenzen eindeutig sind.
• Wenn keine Listen als Eingabe angegeben werden, sind sowohl die leere Liste als auch keine Ausgabe gültige Ausgaben.
• Die Typen der Elemente in den Sequenzen sind irrelevant. (ZB können sie alle ein Typ oder ein Mischmasch von Typen sein, je nachdem, was in Ihrer Sprache praktischer ist.)
• Es muss garantiert sein, dass Ihr Programm / Ihre Funktion auf unbestimmte Zeit endet.
• Das ist Code-Golf , also gewinnt der kürzeste Code für jede Sprache.

Haskell , 84 77 76 Bytes

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

Vielen Dank an @Lynn für 7 Bytes und @ user9549915 für ein Byte!

Probieren Sie es online!

Python 2 , 103 92 79 78 Bytes

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

Probieren Sie es online!

Oder:

Python 3 , 73 Bytes

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

Probieren Sie es online!

-1 durch Ersetzen [x[0]]durch x[:1]gemäß xnor

-13 Bytes durch schamloses Stehlen der Erweiterung, [b[b==x:]for b in A]wie es Neils Antwort andeutet , anstelle einer längeren enumerateAnnäherung.

Nimmt eine Liste von Listen Aals Eingabe. Sind alle Elemente von Aleer, so ist die im ausgewertete Liste ifleer, damit wir das Ende der Rekursion erreicht haben und können print. Ansonsten haben wir eine Liste von einem oder mehreren None; und wir rekursieren.

Jelly , 11 Bytes

FŒ!fЀ⁼ṛɗÐf

Probieren Sie es online!

Wie es funktioniert

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.

Ruby, 66 Bytes

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

Wenn keine nicht leeren Sequenzen vorhanden sind, geben Sie eine leere Sequenz zurück. Andernfalls wiederholen Sie für jede nicht leere Sequenz das Entfernen des ersten Elements und fügen es am Anfang jedes Ergebnisses hinzu. Bei der Implementierung wird davon ausgegangen, dass Elemente garantiert global eindeutig sind, andernfalls a-[b]kann möglicherweise mehr als eine Sequenz aus dem rekursiven Aufruf entfernt werden. Vielleicht ist dies tatsächlich das richtige Verhalten, um doppelte Ausgaben zu vermeiden.

Beispiel 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 Language (Mathematica) , 76 75 71 Bytes

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

Probieren Sie es online!

Naiver Ansatz: Finde alle Permutationen, die Verschachtelungen der Eingabe sind.

Erläuterung

Permutations[Join@@#]

Machen Sie flach <input>und finden Sie alle Permutationen.

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

Finde alle Elemente xso, dass ...

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

Ersetzen Sie alle Elemente in Tiefe 2 <input>durch ihre jeweilige Position in x.

And@@OrderedQ/@ ...

Überprüfen Sie, ob alle Listen der Tiefe 1 sortiert sind (dh in aufsteigender Reihenfolge).

Tatsächliche Implementierung der Verschachtelung, 117 Bytes

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

Probieren Sie es online!

Python 2 , 87 84 Bytes

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

Probieren Sie es online! Port meiner JavaScript-Antwort. Bearbeiten: 3 Bytes dank @ChasBrown gespeichert.

Haskell , 45 Bytes

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

Probieren Sie es online!

Adaptiert von Chas Browns Python-Antwort .

Dies max[[]]ist ein Trick, um einen Basisfall anzugeben, [[]]bei dem die Eingabe nur []Elemente enthält . In diesem Fall ist die Liste für leer, rekursiv leer und max[[]][]gibt [[]].

Wenn wir das erste Element der ausgewählten Liste rekursiv nicht selektiv löschen, erstellen h:twir eine neue Liste mit tvorne und h:tfiltern sie heraus.

JavaScript (Firefox 30-57), 92 Byte

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 Bytes

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.

Nimmt Eingaben als Array von Arrays. -QLässt die Ausgabe die Array-Notation beibehalten.

Probieren Sie es hier aus.

Scala: (soll nicht minimal sein, eher eine klare Referenzressource)

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

Probieren Sie es online!