List 如何实施'；takeUntil'；一份名单？

我想查找第一个

7

之前和之前的所有项目：

val list = List(1,4,5,2,3,5,5,7,8,9,2,7,4)

我的解决办法是：

list.takeWhile(_ != 7) ::: List(7)

结果是：

List(1, 4, 5, 2, 3, 5, 5, 7)

---

还有其他解决方案吗？

这里有一种方法可以通过foldLeft实现，还有一种尾部递归版本可以缩短长列表

还有我在玩这个游戏时使用的测试

import scala.annotation.tailrec
import org.scalatest.WordSpec
import org.scalatest.Matchers

object TakeUntilInclusiveSpec {
  implicit class TakeUntilInclusiveFoldLeft[T](val list: List[T]) extends AnyVal {
    def takeUntilInclusive(p: T => Boolean): List[T] =
      list.foldLeft( (false, List[T]()) )({
        case ((false, acc), x)      => (p(x), x :: acc)
        case (res @ (true, acc), _) => res
      })._2.reverse
  }
  implicit class TakeUntilInclusiveTailRec[T](val list: List[T]) extends AnyVal {
    def takeUntilInclusive(p: T => Boolean): List[T] = {
      @tailrec
      def loop(acc: List[T], subList: List[T]): List[T] = subList match {
        case Nil => acc.reverse
        case x :: xs if p(x) => (x :: acc).reverse
        case x :: xs => loop(x :: acc, xs)
      }
      loop(List[T](), list)
    }
  }
}

class TakeUntilInclusiveSpec extends WordSpec with Matchers {
  //import TakeUntilInclusiveSpec.TakeUntilInclusiveFoldLeft
  import TakeUntilInclusiveSpec.TakeUntilInclusiveTailRec

  val `return` = afterWord("return")
  object lists {
    val one = List(1)
    val oneToTen = List(1, 2, 3, 4, 5, 7, 8, 9, 10)
    val boat = List("boat")
    val rowYourBoat = List("row", "your", "boat")
  }

  "TakeUntilInclusive" when afterWord("given") {
    "an empty list" should `return` {
      "an empty list" in {
        List[Int]().takeUntilInclusive(_ == 7) shouldBe Nil
        List[String]().takeUntilInclusive(_ == "") shouldBe Nil
      }
    }

    "a list without the matching element" should `return` {
      "an identical list" in {
        lists.one.takeUntilInclusive(_ == 20) shouldBe lists.one
        lists.oneToTen.takeUntilInclusive(_ == 20) shouldBe lists.oneToTen
        lists.boat.takeUntilInclusive(_.startsWith("a")) shouldBe lists.boat
        lists.rowYourBoat.takeUntilInclusive(_.startsWith("a")) shouldBe lists.rowYourBoat
      }
    }

    "a list containing one instance of the matching element in the last index" should `return`
    {
      "an identical list" in {
        lists.one.takeUntilInclusive(_ == 1) shouldBe lists.one
        lists.oneToTen.takeUntilInclusive(_ == 10) shouldBe lists.oneToTen
        lists.boat.takeUntilInclusive(_ == "boat") shouldBe lists.boat
        lists.rowYourBoat.takeUntilInclusive(_ == "boat") shouldBe lists.rowYourBoat
      }
    }

    "a list containing one instance of the matching element" should `return` {
      "the elements of the original list, up to and including the match" in {
        lists.one.takeUntilInclusive(_ == 1) shouldBe List(1)
        lists.oneToTen.takeUntilInclusive(_ == 5) shouldBe List(1,2,3,4,5)
        lists.boat.takeUntilInclusive(_ == "boat") shouldBe List("boat")
        lists.rowYourBoat.takeUntilInclusive(_ == "your") shouldBe List("row", "your")
      }
    }

    "a list containing multiple instances of the matching element" should `return` {
      "the elements of the original list, up to and including only the first match" in {
        lists.oneToTen.takeUntilInclusive(_ % 3 == 0) shouldBe List(1,2,3)
        lists.rowYourBoat.takeUntilInclusive(_.length == 4) shouldBe List("row", "your")
      }
    }
  }
}

---

您可以使用以下功能

def takeUntil(list: List[Int]): List[Int] = list match {
  case x :: xs if (x != 7) => x :: takeUntil(xs)
  case x :: xs if (x == 7) => List(x)
  case Nil => Nil
}

val list = List(1,4,5,2,3,5,5,7,8,9,2,7,4)
takeUntil(list) //List(1,4,5,2,3,5,5,7)

尾部递归版本

def takeUntilRec(list: List[Int]): List[Int] = {
    @annotation.tailrec
    def trf(head: Int, tail: List[Int], res: List[Int]): List[Int] = head match {
      case x if (x != 7 && tail != Nil) => trf(tail.head, tail.tail, x :: res)
      case x                            => x :: res
    }
    trf(list.head, list.tail, Nil).reverse
  }

不耐烦者一行：

更通用的版本： 它以任何谓词作为参数。使用

span

执行主要作业：

  implicit class TakeUntilListWrapper[T](list: List[T]) {
    def takeUntil(predicate: T => Boolean):List[T] = {
      list.span(predicate) match {
        case (head, tail) => head ::: tail.take(1)
      }
    }
  }

  println(List(1,2,3,4,5,6,7,8,9).takeUntil(_ != 7))
  //List(1, 2, 3, 4, 5, 6, 7)

  println(List(1,2,3,4,5,6,7,8,7,9).takeUntil(_ != 7))
  //List(1, 2, 3, 4, 5, 6, 7)

  println(List(1,2,3,4,5,6,7,7,7,8,9).takeUntil(_ != 7))
  //List(1, 2, 3, 4, 5, 6, 7)

  println(List(1,2,3,4,5,6,8,9).takeUntil(_ != 7))
  //List(1, 2, 3, 4, 5, 6, 8, 9)

尾部递归版本。 只是为了说明替代方法，它并不比以前的解决方案更有效

implicit class TakeUntilListWrapper[T](list: List[T]) {
  def takeUntil(predicate: T => Boolean): List[T] = {
    def rec(tail:List[T], accum:List[T]):List[T] = tail match {
      case Nil => accum.reverse
      case h :: t => rec(if (predicate(h)) t else Nil, h :: accum)
    }
    rec(list, Nil)
  }
}

---

从

scala.collection.List

借用takeWhile实现并对其进行一些更改：

def takeUntil[A](l: List[A], p: A => Boolean): List[A] = {
    val b = new scala.collection.mutable.ListBuffer[A]
    var these = l
    while (!these.isEmpty && p(these.head)) {
      b += these.head
      these = these.tail
    }
    if(!these.isEmpty && !p(these.head)) b += these.head

    b.toList
  }

---

可能的方法是：

def takeUntil[A](list:List[A])(predicate: A => Boolean):List[A] =
  if(list.isEmpty) Nil
  else if(predicate(list.head)) list.head::takeUntil(list.tail)(predicate)
  else List(list.head)

---

使用内置函数的一些方法：

val list = List(1, 4, 5, 2, 3, 5, 5, 7, 8, 9, 2, 7, 4)
//> list  : List[Int] = List(1, 4, 5, 2, 3, 5, 5, 7, 8, 9, 2, 7, 4)
//Using takeWhile with dropWhile
list.takeWhile(_ != 7) ++ list.dropWhile(_ != 7).take(1)
//> res0: List[Int] = List(1, 4, 5, 2, 3, 5, 5, 7)
//Using take with segmentLength
list.take(list.segmentLength(_ != 7, 0) + 1)

//> res1: List[Int] = List(1, 4, 5, 2, 3, 5, 5, 7)
//Using take with indexOf
list.take(list.indexOf(7) + 1)
//> res2: List[Int] = List(1, 4, 5, 2, 3, 5, 5, 7)
val list=列表（1,4,5,2,3,5,5,7,8,9,2,7,4）
//>list:list[Int]=list（1,4,5,2,3,5,5,7,8,9,2,7,4）
//将takeWhile与dropWhile一起使用
list.takeWhile（！=7）+list.dropWhile（！=7）.take（1）
//>res0:List[Int]=List（1,4,5,2,3,5,5,7）
//使用带分段长度的take
list.take（list.segmentLength（！=7,0）+1）

//>res1:List[Int]=List（1,4,5,2,3,5,5,7）
//使用带indexOf的take
list.take（list.indexOf（7）+1）
//>res2:List[Int]=List（1,4,5,2,3,5,5,7）
这里的许多解决方案不是很有效，因为它们探索整个列表，而不是提前停止。下面是一个使用内置函数的简短解决方案：

def takeUntil[T](c: Iterable[T], f: T => Boolean): Iterable[T] = {
   val index = c.indexWhere(f)
   if (index == -1) c else c.take(index + 1)
}

顺序改变了：（没关系，我的takeWhile和dropWhile被切换了。如果列表中不包含
7
，这将添加一个-这可能是OP想要的，也可能不是OP想要的，但对我来说似乎有点可疑（特别是因为它对空列表没有这样做）.FYI，使用
：+
将元素附加到
列表中是非常低效的。当前您的解决方案是O（N^2）。使用
列表缓冲区替换累加器，或者使用
：
（前置）和
reverse
最终的结果。@Aivean这本应该只是一个快速的演示版本，但它一直困扰着我。所以这里有一个O（n）foldLeft解决方案，以及O（n）如果我必须在生产代码中执行类似操作，我实际上会使用尾部递归版本。
7
不应该包括在内，根据标准库的定义：
scala>List（1,4,5,2,3,5,5,7,8,9,2,7,4）。takeWhile（！=7）res0:List[Int]=List（1,4,5,2,3,5,5）。提示-考虑使用<代码>列表→FordRebug 。但是总体上，我觉得你的问题中的大部分都是最短、最冗长的方式。我之所以使用这个答案是因为我实际上希望<>代码> Stutabor直到——并且这会在列表中保存一个迭代。这个函数不是尾部递归的，所以它可能会被堆栈失败。对于长列表，该方法的值较低。仅供参考。仅供参考，这种方法不是尾部递归的（在长输入列表中可能失败）。
def takeUntil[T](c: Iterable[T], f: T => Boolean): Iterable[T] = {
   val index = c.indexWhere(f)
   if (index == -1) c else c.take(index + 1)
}