Trình tự xen kẽ đại diện cho một sự hợp nhất tùy ý của một số số trình tự.

Một chuỗi xen kẽ có thể được thực hiện bằng cách nối các phần tử vào danh sách từng cái một từ một số danh sách, chọn phần tử tiếp theo từ một số danh sách mỗi lần. Do đó, một chuỗi xen kẽ sẽ chứa chính xác các yếu tố giống nhau của tất cả các danh sách được kết hợp, theo thứ tự phù hợp với tất cả các danh sách.

Sự xen kẽ duy nhất của 1 danh sách là cùng một danh sách.

Thử thách

Thách thức của bạn là tạo ra một chức năng / chương trình có số lượng trình tự tùy ý và đưa ra tất cả các xen kẽ có thể có của các chuỗi đó.

Ví dụ

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]

Quy tắc

• Lỗ hổng tiêu chuẩn bị cấm (duh)
• Đầu vào có thể được lấy ở bất kỳ định dạng hợp lý nào, ví dụ như một danh sách các danh sách, danh sách khác nhau của danh sách, danh sách tham số, v.v ... miễn là không rõ ràng nơi danh sách bắt đầu và kết thúc.
• Đầu ra có thể ở bất kỳ định dạng hợp lý nào, miễn là rõ ràng nơi danh sách bắt đầu và kết thúc. Các đầu ra hợp lệ bao gồm, nhưng không nhất thiết giới hạn ở:
  • thiết bị xuất chuẩn, với một danh sách trên mỗi dòng
  • Một danh sách các danh sách
  • Trình lặp trên danh sách (có thể được thực hiện với trình tạo nếu ngôn ngữ của bạn có chúng)
• Thứ tự của các xen kẽ mang lại không quan trọng, tuy nhiên, không nên có bất kỳ xen kẽ lặp đi lặp lại.
• Để đơn giản hóa phát hiện lặp lại, bạn có thể giả sử rằng tất cả các yếu tố trên tất cả các chuỗi đầu vào là duy nhất.
• Nếu không có danh sách nào làm đầu vào, cả danh sách trống và không có đầu ra đều là đầu ra hợp lệ.
• Các loại yếu tố trong chuỗi là không liên quan. (ví dụ: tất cả chúng có thể là một loại hoặc hỗn hợp các loại, tùy theo ngôn ngữ của bạn thuận tiện hơn)
• Chương trình / chức năng của bạn phải được đảm bảo chấm dứt trong một khoảng thời gian hữu hạn.
• Đây là môn đánh gôn , vì vậy mã ngắn nhất cho mỗi ngôn ngữ sẽ thắng.

Haskell , 84 77 76 byte

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

Cảm ơn @Lynn cho 7 byte và @ user9549915 cho một byte!

Hãy thử trực tuyến!

Python 2 , 103 92 79 78 byte

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

Hãy thử trực tuyến!

Hoặc là:

Python 3 , 73 byte

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

Hãy thử trực tuyến!

-1 bằng cách thay thế [x[0]]bằng x[:1]theo xnor

-13 byte bằng cách ăn cắp một cách đáng xấu hổ mở rộng theo [b[b==x:]for b in A]đề xuất của câu trả lời của Neil thay vì enumeratetiếp cận lâu hơn .

Lấy danh sách các danh sách Alàm đầu vào. Nếu tất cả các phần tử Atrống, thì danh sách được đánh giá ifsẽ trống, vì vậy chúng tôi đã đạt đến cuối của đệ quy và có thể print. Mặt khác, chúng tôi có một danh sách một hoặc nhiều None; và chúng tôi tái diễn.

Thạch , 11 byte

FŒ!fЀ⁼ṛɗÐf

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

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

Nếu không có chuỗi không trống, trả về một chuỗi trống. Mặt khác, đối với mỗi chuỗi không trống, lặp lại với phần tử đầu tiên được loại bỏ sau đó thêm nó vào đầu mỗi kết quả. Việc triển khai sử dụng giả định rằng các phần tử được đảm bảo là duy nhất trên toàn cầu, nếu không a-[b]có khả năng có thể xóa hơn 1 chuỗi khỏi lệnh gọi đệ quy. Mặc dù về sự phản chiếu, có lẽ đó thực sự là hành vi đúng để tránh đầu ra trùng lặp.

Ví dụ 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]]

Ngôn ngữ Wolfram (Mathicala) , 76 75 71 byte

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

Hãy thử trực tuyến!

Cách tiếp cận ngây thơ: tìm tất cả các hoán vị là xen kẽ của đầu vào.

Giải trình

Permutations[Join@@#]

Làm phẳng <input>và tìm tất cả các hoán vị của nó.

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

Tìm tất cả các yếu tố xsao cho ...

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

Thay thế tất cả các mục ở độ sâu-2 <input>bằng vị trí tương ứng của chúng trong x.

And@@OrderedQ/@ ...

Kiểm tra xem tất cả các danh sách độ sâu-1 đã được sắp xếp chưa (nghĩa là theo thứ tự tăng dần).

Thực tế thực hiện xen kẽ, 117 byte

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

Hãy thử trực tuyến!

Python 2 , 87 84 byte

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

Hãy thử trực tuyến! Cổng câu trả lời JavaScript của tôi. Chỉnh sửa: Đã lưu 3 byte nhờ @ChasBrown.

Haskell , 45 byte

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

Hãy thử trực tuyến!

Chuyển thể từ câu trả lời Python của Chas Brown .

Đây max[[]]là một mẹo để đưa ra một trường hợp cơ bản [[]]khi đầu vào chỉ chứa []các phần tử. Trong trường hợp đó, danh sách được sử dụng cho trống, đệ quy là trống và max[[]][]đưa ra [[]].

Khi đệ quy, thay vì bỏ chọn lọc phần tử đầu tiên của danh sách đã chọn h:t, chúng tôi tạo một danh sách mới tở phía trước và h:tđược lọc ra.

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 byte

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.

Đưa đầu vào như một mảng của mảng. -Qlàm cho đầu ra bảo toàn ký hiệu mảng.

Hãy thử nó ở đây.

Scala: (không có ý định tối thiểu, nhiều tài nguyên tham khảo rõ ràng hơn)

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

Hãy thử trực tuyến!