Scala 插层的反作用是什么，如何实现？

讨论如何以交替方式交错两个列表，即插入它们

• “插入”的反义词叫什么
• 在Scala中有没有一种惯用的方法来实现这一点

---

本主题将就此进行讨论
可能包括“去夹层”、“去夹层”、“超级碳酸酯”、“外层碳酸酯”和“巧克力”；-）
假设我们选择“extracalate”，它可以作为一个折叠式实现：

def extracalate[A](a: List[A]) = 
    a.foldRight((List[A](), List[A]())){ case (b, (a1,a2)) => (b :: a2, a1) }

例如：

val mary = List("Mary", "had", "a", "little", "lamb")
extracalate(mary)                              
//>  (List(Mary, a, lamb),List(had, little)

请注意，只有在以下任一情况下，才能重建原始列表：
• 输入列表的长度相同，或者
• 第一个列表比第二个列表长1
第二种情况实际上对算法很有用，其中插入了纬度位和经度位，但可能有奇数个位
还要注意，链接问题中的

插入
的定义与中的定义不同，后者将一个列表穿插在一个列表列表之间

更新：对于任何折叠，我们提供了一个起始值和一个应用于输入列表中每个值的函数。此函数用于修改起始值并将其传递到折叠的下一步。
这里，我们从一对空输出列表开始：
（列表[a]（），列表[a]（））
然后，对于输入列表中的每个元素，我们使用cons
：
将其添加到一个输出列表的前面。但是，每次调用函数时，我们也交换两个输出列表的顺序<代码>（a1，a2）
变为
（b:：a2，a1）
。这将以交替方式在两个输出列表之间划分输入列表。因为它是一个右折叠，所以我们从输入列表的末尾开始，这是按正确顺序获得每个输出列表所必需的。从起始值到最终值，我们将得到：

([], [])
([lamb], [])
([little],[lamb])
([a, lamb],[little])
([had, little],[a, lamb])
([Mary, a, lamb],[had, little])

此外，使用标准方法

val mary = List("Mary", "had", "a", "little", "lamb")
       //> mary  : List[String] = List(Mary, had, a, little, lamb)
val (f, s) = mary.zipWithIndex.partition(_._2 % 2 == 0)
       //> f  : List[(String, Int)] = List((Mary,0), (a,2), (lamb,4))
       //| s  : List[(String, Int)] = List((had,1), (little,3))
(f.unzip._1, s.unzip._1) 
       //> res0: (List[String], List[String]) = (List(Mary, a, lamb),List(had, little))

虽然不是真的推荐它，但在性能上，折叠式广告将轻而易举地击败它

用另一种方法剥猫皮

val g = mary.zipWithIndex.groupBy(_._2 % 2) 
        //> g  : scala.collection.immutable.Map[Int,List[(String, Int)]] = Map(1 -> List
        //| ((had,1), (little,3)), 0 -> List((Mary,0), (a,2), (lamb,4)))
 (g(0).unzip._1, g(1).unzip._1)
       //> res1: (List[String], List[String]) = (List(Mary, a, lamb),List(had, little))

也会很慢
我认为它不如@DNA的答案，因为它的代码更多，而且需要通过列表两次

scala> list
res27: List[Int] = List(1, 2, 3, 4, 5)

scala> val first = list.zipWithIndex.filter( x => x._1 % 2 == 1).map(x => x._2)
first: List[Int] = List(0, 2, 4)

scala> val second = list.zipWithIndex.filter( x => x._1 % 2 == 0).map(x => x._2)
second: List[Int] = List(1, 3)

scala> (first, second)
res28: (List[Int], List[Int]) = (List(0, 2, 4),List(1, 3))

自我推销，不错；）<代码>列表（“玛丽”、“曾经”、“一个”、“小”、“羔羊”、“它的”）。分组（2）。映射{p=>（p（0），p（1））}。toList.unzip

。如果列表长度为奇数，则失败，尽管我添加了打印语句，但我没有完全理解您的

折叠功能。你能说说它在做什么吗？