Question

假设我的列表看起来像这样：

List(0,5,34,0,9,0,0,0)

我最终想要的是：

List(0,5,34,0,9)

我正在移除所有尾随零。有没有方法，如：

list.trimRight(_ == 0)

那会实现吗？我可以从头开始编写它，但在我看来它是std集合中的东西吗？

我想出了：

list.take(list.lastIndexWhere(_ != 0) + 1)

有更好的方法吗？

Answer 1

如果你想知道哪个是优雅，那么我会说

list.reverse.dropWhile(_ == 0).reverse

因为它只需要引用一次输入，意图非常明确。

如果您想知道哪个效率最高，您需要进行一些基准测试。结果（对于您的简短测试列表）可能会让您感到惊讶！

// Slowest
191 ns     dhg's EnhancedSeq
173 ns     user unknown's custom dropRight
 91 ns     andyczerwonka's take/lastIndexWhere
 85 ns     Rex's :\ (foldRight) -- see below
 60 ns     dhg / Daniel's reverse/dropWhile/reverse
 52 ns     Rex's customDropTrailingZeros -- see below
// Fastest

可能存在一些适度的机器到机器的差异，但基本上这是一种情况，对于简短的列表，花哨并没有帮助你。很长的名单可能会发生很大的变化。

这是折叠版本（但是大型列表上的堆栈溢出）：

(list :\ list.take(0)){ (x,ys) => if (x==0 && ys.isEmpty) ys else x :: ys }

这是自定义版本（完全非通用 - 仅适用于此特定任务！）：

@annotation.tailrec def customDropZeros(
  xs: List[Int],
  buffer: Array[Int] = new Array[Int](16),
  n: Int = 0
): List[Int] = {
  if (xs.isEmpty) {
    var ys = xs
    var m = n
    while (m>0 && buffer(m-1)==0) m -= 1
    var i = m-1
    while (i>=0) {
      ys = buffer(i) :: ys
      i -= 1
    }
    ys
  }
  else {
    val b2 = (
      if (n<buffer.length) buffer
      else java.util.Arrays.copyOf(buffer, buffer.length*2)
    )
    b2(n) = xs.head
    customDropZeros(xs.tail, b2, n+1)
  }
}

TL;博士

使用reverse dropWhile reverse除非您有充分的理由否则。它出人意料地快速且令人惊讶地清晰。

Answer 2

我想我对list.take(list.lastIndexWhere(_ != 0)+1)的回答是这样做的。

Answer 3

scala> val xs = List(0,5,34,0,9,0,0,0)
xs: List[Int] = List(0, 5, 34, 0, 9, 0, 0, 0)

scala> xs.reverse.dropWhile(_ == 0).reverse
res1: List[Int] = List(0, 5, 34, 0, 9)

修改

这是一种一次通过（O（n））方式，将dropWhileRight方法添加到Seq

class EnhancedSeq[A, Repr <: Seq[A]](seq: SeqLike[A, Repr]) { def dropRightWhile[That](p: A => Boolean)(implicit bf: CanBuildFrom[Repr, A, That]): That = { val b = bf(seq.asInstanceOf[Repr]) val buffer = collection.mutable.Buffer[A]() for (x <- seq) { buffer += x if (!p(x)) { b ++= buffer buffer.clear() } } b.result } } implicit def enhanceSeq[A, Repr <: Seq[A]](seq: SeqLike[A, Repr]) = new EnhancedSeq(seq)

你就这样使用它：

scala> List(0,5,34,0,9,0,0,0).dropRightWhile(_ == 0) res2: List[Int] = List(0, 5, 34, 0, 9)

Answer 4

Scala中没有这样的方法，List在更改它的“结束”时效率很低。喜欢Vector。

这与List相当合适（我的其他建议充满了错误，我删除了它）：

list.reverse.dropWhile(_ == 0).reverse

Answer 5

您可以遍历列表，并缓冲0，直到找到一些非0。如果找到not-0，则将缓冲区附加到结果到目前为止，然后继续。但是如果你的List以0结尾，你就扔掉了最后一个缓冲区。

但是 - 最后，还需要reverse。

val xs = List(0,5,34,0,9,0,0,0)

import annotation._
@tailrec    
def dropRight [T] (l: List[T], p: (T=>Boolean), carry: List[T]=List.empty, buf: List[T]=List.empty): List[T] = {
  if (l.isEmpty) carry.reverse else 
  if (p (l.head)) dropRight (l.tail, p, l.head :: buf ::: carry, List.empty) else 
  dropRight (l.tail, p, carry, l.head :: buf) }

dropRight (xs, (x: Int) => x != 0) 
res122: List[Int] = List(0, 5, 34, 0, 9)

如果您最终对订单不感兴趣并且可以省略“反向”调用，那可能会很有趣，但为什么您只会丢弃最后一个Ts？

基准： benchmark diagram

我进一步增加了尺寸，但重复了这种模式。

如何删除Scala集合中的尾随元素？

5 个答案:

TL;博士

更新：包含dhg的算法，这是非常高效的。