从 Seq 更少/更大的元素中过滤，并且只有一个相等

Question

我想在 Scala 中实现一种方法，该方法从 Seq 元素中过滤，例如大于提供的值，并额外返回一个相等的元素。例如：

greaterOrEqual(Seq(1,2,3,3,4), 3) shouldBe Seq(3,4)

我最终得到了这样的方法：

def greaterOrEqual(
      seq: ArrayBuffer[Long],
      value: Long
  ): ArrayBuffer[Long] = {
    val greater = seq.filter(_ > value)
    val equal = seq.filter(_ == value)
    if (equal.isEmpty) {
      greater
    } else {
      equal.tail ++ greater
    }
  }

但不知何故，它对我来说看起来不太好:) 此外，我希望有这个方法的通用版本，我不仅可以使用 Long 类型，还可以使用自定义案例类。

你有什么建议吗？ 提前致谢。

Answer 1

def foo[A : Ordering[A]](seq: Seq[A], value: A) = seq.find(_ == value).toList ++ seq.filter(implicitly[Ordering[A]].gt(_,value))

或者（不同的风格）

def foo[A](seq: Seq[A], value: A)(implicit ord: Ordering[A]) = {
   import ord._
   seq.find(_ == value).toList ++ seq.filter(_ > value)
}

以下代码已弃用

罢工>

scala> def foo[A <% Ordered[A]](seq: Seq[A], value: A) = seq.find(_ == value).toList ++  seq.filter(_ > value)
foo: [A](seq: Seq[A], value: A)(implicit evidence$1: A => Ordered[A])List[A]

scala> foo(Seq(1,2,3,3,4,4,5),3)
res8: List[Int] = List(3, 4, 4, 5)

Answer 2

这是我的看法（保留原始顺序）。

import scala.collection.mutable.ArrayBuffer

def greaterOrEqual[A]( seq :ArrayBuffer[A], value :A
                     )(implicit ord :Ordering[A]
                      ) : ArrayBuffer[A] =
  seq.foldLeft((ArrayBuffer.empty[A],true)){
    case (acc, x)        if ord.lt(x,value) => acc
    case ((acc,bool), x) if ord.gt(x,value) => (acc :+ x, bool)
    case ((acc,true), x)                    => (acc :+ x, false)
    case (acc, _)                           => acc
  }._1

测试：

greaterOrEqual(ArrayBuffer.from("xawbaxbt"), 'b')
//res0: ArrayBuffer[Char] = ArrayBuffer(x, w, b, x, t)

Answer 3

对于列表上的简单尾递归算法来说，这是一个很好的问题。

def greaterOrEqual[T : Ordering](elements: List[T])(value: T): List[T] = {
  import Ordering.Implicits._

  @annotation.tailrec
  def loop(remaining: List[T], alreadyIncludedEqual: Boolean, acc: List[T]): List[T] =
    remaining match {
      case x :: xs =>
        if (!alreadyIncludedEqual && x == value)
          loop(remaining = xs, alreadyIncludedEqual = true, x :: acc)
        else if (x > value)
          loop(remaining = xs, alreadyIncludedEqual, x :: acc)
        else
          loop(remaining = xs, alreadyIncludedEqual, acc)

      case Nil =>
        acc.reverse
    }

  loop(remaining = elements, alreadyIncludedEqual = false, acc = List.empty)
}

你可以这样使用：

greaterOrEqual(List(1, 3, 2, 3, 4, 0))(3)
// val res: List[Int] = List(3, 4)

Answer 4

你可以使用下面的sn-p：

val list = Seq(1,2,3,3,4)
val value = 3

list.partition(_>=3)._1.toSet.toSeq

这里的分区方法将列表分成两个列表。第一个列表满足给定条件，第二个列表包含其余元素。

Answer 5

对于泛型方法，您可以使用隐式Ordering。任何可以比较元素的类型都可以通过greaterOrEqual方法处理。

import scala.math.Ordering._

def greaterOrEqual[T](seq: Seq[T], value: T)(implicit ordering: Ordering[T]): Seq[T] = {
  @scala.annotation.tailrec
  def go(xs: List[T], value: T, acc: List[T]): List[T] = {
    xs match {
      case Nil => acc
      case head :: rest if ordering.compare(head, value) == 0 => rest.foldLeft(head :: acc){
        case (result, x) if ordering.compare(x, value) > 0 => x :: result
        case (result, _) => result
      }
      case head :: rest if ordering.compare(head, value) > 0 => go(rest, value, head :: acc)
      case _ :: rest => go(rest, value, acc)
    }
  }
  go(seq.toList, value, List.empty[T]).reverse
}