Scala เป็นวิธีที่ใช้สำนวนในการ "ลบ" องค์ประกอบหนึ่งออกจากรายการที่ไม่เปลี่ยนรูปได้อย่างไร

ฉันมีรายการซึ่งอาจมีองค์ประกอบที่จะเปรียบเทียบว่าเท่ากัน ฉันต้องการรายการที่คล้ายกัน แต่มีการลบองค์ประกอบหนึ่งรายการ ดังนั้นจาก (A, B, C, B, D) ฉันต้องการจะสามารถ "ลบ" B เพียงตัวเดียวเพื่อให้ได้เช่น (A, C, B, D) ลำดับขององค์ประกอบในผลลัพธ์ไม่สำคัญ

ฉันมีรหัสการทำงานที่เขียนด้วยวิธีที่ได้รับแรงบันดาลใจจาก Lisp ใน Scala มีวิธีสำนวนมากกว่านี้ไหม?

บริบทคือเกมไพ่ที่มีการเล่นไพ่มาตรฐานสองสำรับดังนั้นอาจมีไพ่ที่ซ้ำกัน แต่ยังคงเล่นทีละใบ

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)
}

ฉันไม่เห็นความเป็นไปได้นี้ในคำตอบด้านบนดังนั้น:

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)

แก้ไข:

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

เหมือน :-) เสน่ห์.

คุณสามารถใช้filterNotวิธีนี้

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

คุณสามารถลองสิ่งนี้:

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)

และเป็นวิธีการ:

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

แต่น่าเสียดายที่ลำดับชั้นของคอลเลกชันมีตัวเองเป็นบิตของระเบียบที่มีอยู่บน- Listเพื่อให้ArrayBufferได้ผลเช่นเดียวกับที่คุณคาดหวัง:

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

แต่น่าเศร้าที่Listลงเอยด้วยการfilterNotใช้งานสไตล์จึง "ผิด" และส่งคำเตือนการเลิกใช้งานมาที่คุณ (สมเหตุสมผลเพียงพอเนื่องจากเป็นสิ่งที่เกิดขึ้นจริง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)

ดังนั้นสิ่งที่ง่ายที่สุดในการทำคือแปลงListเป็นคอลเล็กชันที่ทำสิ่งนี้ได้ถูกต้องแล้วแปลงกลับอีกครั้ง:

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

หรือคุณสามารถใช้ตรรกะของรหัสที่คุณมี แต่ทำให้สไตล์เป็นสำนวนมากขึ้น:

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
 }

เกี่ยวกับ

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

ถ้าคุณเห็นreturnมีบางอย่างผิดปกติ

// 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
}

ในฐานะที่เป็นวิธีแก้ปัญหาที่เป็นไปได้คุณสามารถค้นหาดัชนีขององค์ประกอบแรกที่เหมาะสมจากนั้นลบองค์ประกอบที่ดัชนีนี้:

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

อีกหนึ่งความคิดเกี่ยวกับวิธีการใช้การพับ:

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

โซลูชันการเรียกซ้ำหางทั่วไป:

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)

    }

}