Переплетені послідовності являють собою довільне злиття деякої кількості послідовностей.

Переплетену послідовність можна зробити, додаючи елементи до списку один за одним із деякої кількості списків, обираючи наступний елемент із якогось списку кожен раз. Тому перемежована послідовність буде містити абсолютно однакові елементи всіх списків разом у порядку, узгодженому з усіма списками.

Єдине переплетення 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]

Правила

• Заборонено стандартні лазівки (duh)
• Введення даних може бути прийнято у будь-якому розумному форматі, наприклад, список списків, список варагг списків, списки параметрів тощо ... до тих пір, поки це однозначно, де списки починаються та закінчуються.
• Вихід може бути у будь-якому розумному форматі, якщо зрозуміло, де починаються та закінчуються списки. Дійсні результати включають, але не обов'язково обмежуються:
  • stdout, з одним списком на рядок
  • Список списків
  • Ітератор над списками (може бути реалізований з генератором, якщо у вас є їх мова)
• Порядок виведених переплетень не має значення, однак повторних переплетень не повинно бути.
• Для спрощення повторного виявлення ви можете припустити, що всі елементи в усіх вхідних послідовностях є унікальними.
• Якщо не вказано списків як вхідних даних, і порожній список, і вихідні дані не є дійсними.
• Типи елементів у послідовностях не мають значення. (наприклад, вони можуть бути одного типу або мішанина типів, що зручніше для вашої мови)
• Ваша програма / функція повинна бути гарантована, що вона припиниться протягом обмеженого часу.
• Це код-гольф , тому найкоротший код для кожної мови виграє.

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]

Дякуємо @Lynn за 7 байт та @ user9549915 за байт!

Спробуйте в Інтернеті!

Python 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

-13 байт, безсоромно красти розширюючись, [b[b==x:]for b in A]як запропоновано відповіддю Ніла замість більш тривалого enumerateпідходу.

Приймає список списків Aяк вхідний. Якщо всі елементи Aпусті порожні, то список, оцінений у ifзаповіті, буде порожнім, тому ми дійшли до кінця рекурсії і можемо print. В іншому випадку у нас є список одного або декількох 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]можуть потенційно видалити більше 1 послідовності з рекурсивного виклику. Незважаючи на роздуми, можливо, це насправді правильна поведінка, щоб уникнути дублювання результатів.

Приклад 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]]

Мова Вольфрама (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. Редагувати: збережено 3 байти завдяки @ChasBrown.

Haskell , 45 байт

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

Спробуйте в Інтернеті!

Адаптований з відповіді Чатона Брауна на Python .

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

Спробуйте в Інтернеті!