交织序列

18

交错的序列表示一些序列的任意合并。

可以通过从一定数量的列表中将元素逐一追加到列表中，然后每次从某个列表中选择下一个元素来形成交错序列。因此，交错序列将包含与所有列表完全相同的元素，并与所有列表一致。

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）
  • 输入可以采用任何合理的格式，例如列表列表，列表的vararg列表，参数列表等，只要列表的开始和结束位置是明确的即可。
  • 输出可以是任何合理的格式，只要可以清楚地知道列表的开始和结束位置即可。有效输出包括但不限于：
    • 标准输出，每行一个列表
    • 清单清单
    • 列表上的迭代器（如果您的语言有列表，可以用生成器实现）
  • 产生的交错的顺序无关紧要，但是，不应有任何重复的交错。
  • 为了简化重复检测，您可以假定所有输入序列中的所有元素都是唯一的。
  • 如果未提供任何列表作为输入，则空列表和无输出均为有效输出。
  • 序列中元素的类型无关紧要。（例如，它们全都可以是一种类型，也可以是多种类型的混合物，以您的语言中较方便的一种为准）
  • 您的程序/功能必须保证在有限的时间内终止。
  • 这是代码高尔夫球，因此每种语言的最短代码胜出。
code-golf  sequence 
— 牛f
source
没有列表的唯一交错是空列表。这是否意味着我们必须输出[[]]而不是[]在没有列表作为输入的情况下？
— 暴民埃里克（Erik the Outgolfer）'18年
另外，列表的长度是否相等？
— 暴民埃里克（Erik the Outgolfer）
我想，如果没有列表作为输入给出，则从数学上讲，不将任何列表作为输出是明智的。我会两者都允许。所有输出列表的长度将相等。输入列表的长度可能有所不同。
— Beefster

Answers:

5

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。然后我们递归。

— 查斯·布朗
source
[x[0]]是x[:1]
— xnor18年
@xnor：当然！谢谢！
— Chas Brown
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.
— 丹尼斯
source
3

Ruby，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]]

— 历史学家
source
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/@ ...

检查是否所有的depth-1列表都已排序（即，升序排列）。

交织的实际实现，117字节

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

在线尝试！

— 郑焕民
source
2

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个字节。

— 尼尔
source
-3替换sum(a,[])为any(a)。
— Chas Brown '18
@ChasBrown谢谢，我不太了解Python。
— 尼尔
尼尔：好吧，我想:)。sum(a,[])在某些情况下可以很好地使用！
— Chas Brown
2

Haskell，45个字节

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

在线尝试！

改编自Chas Brown的Python答案。

这max[[]]是提供[[]]输入仅包含[]元素的基本情况的技巧。在这种情况下，用于清空，递归的列表为空，并max[[]][]给出[[]]。

递归时，我们没有选择性地删除所选列表的第一个元素h:t，而是创建了一个新列表t，该列表位于最前面并被h:t过滤掉。

— 异或
source
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]]:[[]]
— 尼尔
source
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使输出保留数组符号。

在这里尝试。

— 尼特
source
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))))
}

在线尝试！

— 萨蒂格拉哈
source
1
您至少应该尝试使用此代码……
— Timtech '18
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.