Cách Scala thành ngữ để “loại bỏ” một phần tử khỏi Danh sách bất biến là gì?

Tôi có một Danh sách, có thể chứa các phần tử sẽ được so sánh như nhau. Tôi muốn có một Danh sách tương tự, nhưng đã loại bỏ một phần tử. Vì vậy, từ (A, B, C, B, D) tôi muốn có thể "loại bỏ" chỉ một B để có được ví dụ: (A, C, B, D). Thứ tự của các phần tử trong kết quả không quan trọng.

Tôi có mã làm việc, được viết theo cách lấy cảm hứng từ Lisp trong Scala. Có cách nào dễ hiểu hơn để làm điều này không?

Bối cảnh là một trò chơi đánh bài mà hai bộ bài tiêu chuẩn đang diễn ra nên có thể có những quân bài trùng nhau nhưng vẫn được chơi một lượt.

def removeOne(c: Card, left: List[Card], right: List[Card]): List[Card] = {
  if (Nil == right) {
    return left
  }
  if (c == right.head) {
    return left ::: right.tail
  }
  return removeOne(c, right.head :: left, right.tail)
}

def removeCard(c: Card, cards: List[Card]): List[Card] = {
  return removeOne(c, Nil, cards)
}

Tôi chưa thấy khả năng này trong các câu trả lời ở trên, vì vậy:

scala> def remove(num: Int, list: List[Int]) = list diff List(num)
remove: (num: Int,list: List[Int])List[Int]

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

Biên tập:

scala> remove(2,List(2,2,2))
res0: List[Int] = List(2, 2)

Như một cái duyên :-).

Bạn có thể sử dụng filterNotphương pháp này.

val data = "test"
list = List("this", "is", "a", "test")
list.filterNot(elm => elm == data)

Bạn có thể thử điều này:

scala> val (left,right) = List(1,2,3,2,4).span(_ != 2)
left: List[Int] = List(1)
right: List[Int] = List(2, 3, 2, 4)

scala> left ::: right.tail                            
res7: List[Int] = List(1, 3, 2, 4)

Và như phương pháp:

def removeInt(i: Int, li: List[Int]) = {
   val (left, right) = li.span(_ != i)
   left ::: right.drop(1)
}

Thật không may, hệ thống phân cấp các bộ sưu tập có mình thành một chút của một mớ hỗn độn với -trên List. Vì ArrayBuffernó hoạt động giống như bạn có thể hy vọng:

scala> collection.mutable.ArrayBuffer(1,2,3,2,4) - 2
res0: scala.collection.mutable.ArrayBuffer[Int] = ArrayBuffer(1, 3, 2, 4)

nhưng, thật đáng buồn, Listkết thúc với filterNotviệc triển khai một kiểu và do đó thực hiện "điều sai" và đưa ra cảnh báo không dùng nữa cho bạn (đủ hợp lý, vì nó thực sự được nhập vào filterNot):

scala> List(1,2,3,2,4) - 2                          
warning: there were deprecation warnings; re-run with -deprecation for details
res1: List[Int] = List(1, 3, 4)

Vì vậy, điều dễ dàng nhất để làm là chuyển đổi Listthành một bộ sưu tập thực hiện đúng điều này, và sau đó chuyển đổi trở lại:

import collection.mutable.ArrayBuffer._
scala> ((ArrayBuffer() ++ List(1,2,3,2,4)) - 2).toList
res2: List[Int] = List(1, 3, 2, 4)

Ngoài ra, bạn có thể giữ nguyên logic của mã mà bạn có nhưng làm cho văn phong trở nên thành ngữ hơn:

def removeInt(i: Int, li: List[Int]) = {
  def removeOne(i: Int, left: List[Int], right: List[Int]): List[Int] = right match {
    case r :: rest =>
      if (r == i) left.reverse ::: rest
      else removeOne(i, r :: left, rest)
    case Nil => left.reverse
  }
  removeOne(i, Nil, li)
}

scala> removeInt(2, List(1,2,3,2,4))
res3: List[Int] = List(1, 3, 2, 4)

 def removeAtIdx[T](idx: Int, listToRemoveFrom: List[T]): List[T] = {
    assert(listToRemoveFrom.length > idx && idx >= 0)
    val (left, _ :: right) = listToRemoveFrom.splitAt(idx)
    left ++ right
 }

Làm thế nào về

def removeCard(c: Card, cards: List[Card]) = {
  val (head, tail) = cards span {c!=}   
  head ::: 
  (tail match {
    case x :: xs => xs
    case Nil => Nil
  })
}

Nếu bạn thấy return, có điều gì đó không ổn.

// throws a MatchError exception if i isn't found in li
def remove[A](i:A, li:List[A]) = {
   val (head,_::tail) = li.span(i != _)
   head ::: tail
}

Là một trong những giải pháp khả thi, bạn có thể tìm chỉ mục của phần tử phù hợp đầu tiên và sau đó xóa phần tử tại chỉ mục này:

def removeOne(l: List[Card], c: Card) = l indexOf c match {
    case -1 => l
    case n => (l take n) ++ (l drop (n + 1))
}

Chỉ là một suy nghĩ khác về cách thực hiện việc này bằng cách sử dụng nếp gấp:

def remove[A](item : A, lst : List[A]) : List[A] = {
    lst.:\[List[A]](Nil)((lst, lstItem) => 
       if (lstItem == item) lst else lstItem::lst )
}

Giải pháp đệ quy đuôi chung:

def removeElement[T](list: List[T], ele: T): List[T] = {
    @tailrec
    def removeElementHelper(list: List[T],
                            accumList: List[T] = List[T]()): List[T] = {
      if (list.length == 1) {
        if (list.head == ele) accumList.reverse
        else accumList.reverse ::: list
      } else {
        list match {
          case head :: tail if (head != ele) =>
            removeElementHelper(tail, head :: accumList)
          case head :: tail if (head == ele) => (accumList.reverse ::: tail)
          case _                             => accumList
        }
      }
    }
    removeElementHelper(list)
  }

val list : Array[Int] = Array(6, 5, 3, 1, 8, 7, 2)
val test2 = list.splitAt(list.length / 2)._2
val res = test2.patch(1, Nil, 1)

object HelloWorld {

    def main(args: Array[String]) {

        var months: List[String] = List("December","November","October","September","August", "July","June","May","April","March","February","January")

        println("Deleting the reverse list one by one")

        var i = 0

        while (i < (months.length)){

            println("Deleting "+months.apply(i))

            months = (months.drop(1))

        }

        println(months)

    }

}