[SCALA] 불변의 목록에서 "제거"하나 개의 요소에 관용적 스칼라 방법은 무엇입니까?

불변의 목록에서 "제거"하나 개의 요소에 관용적 스칼라 방법은 무엇입니까?

나는 같은 것으로 비교됩니다 요소를 포함 할 수있는 목록을 가지고있다. 나는 비슷한 목록을 좋아하지만, 하나 개의 요소로 제거한다. 그래서 (A, B, C, B, D)에서 나는 "제거"예를 얻기 위해 한 B 수 있도록하고 싶습니다 (A, C, B, D). 결과의 요소의 순서는 중요하지 않습니다.

나는 스칼라에 리스프 영감 방식으로 작성, 코드를 작업했다. 더 관용적 방법이 있나요 이것을하기 위해?

문맥은 표준 카드의 두 데크는 플레이에 카드 게임, 그래서이 할 수있다 중복 카드하지만 한 번에 여전히 연주를합니다.

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

해결법

1. ==============================

   1.그래서, 위의 답변에서 이러한 가능성을 보지 못했다 :

   그래서, 위의 답변에서 이러한 가능성을 보지 못했다 :

   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)
   

   마법처럼 :-).

2. ==============================

   2.당신은 filterNot 방법을 사용할 수 있습니다.

   당신은 filterNot 방법을 사용할 수 있습니다.

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

3. ==============================

   3.당신이 시도 할 수 :

   당신이 시도 할 수 :

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

4. ==============================

   4.목록에 - 불행하게도, 컬렉션 계층 구조와 혼란의 비트에 자신을 얻었다. ArrayBuffer를 들어 당신이 희망 할 수처럼 작동합니다 :

   목록에 - 불행하게도, 컬렉션 계층 구조와 혼란의 비트에 자신을 얻었다. ArrayBuffer를 들어 당신이 희망 할 수처럼 작동합니다 :

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

   하지만, 슬프게도, 목록은 filterNot 스타일의 구현을 끝내었고, 따라서 "잘못된 일"수행하고 (이것은 실제로 filterNoting 때문에, 분별있는만큼) 당신에 중단 경고가 발생합니다 :

   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)
   

   그래서 틀림없이 할 수있는 가장 쉬운 방법은이 권리를 수행 한 다음 다시 변환 집합으로 변환 목록은 다음과 같습니다

   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)
   

5. ==============================

   5.

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

6. ==============================

   6.

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

7. ==============================

   7.하나 개의 가능한 솔루션으로이 인덱스의 첫 번째 적합한 요소의 인덱스 다음 제거 요소를 찾을 수 있습니다 :

   하나 개의 가능한 솔루션으로이 인덱스의 첫 번째 적합한 요소의 인덱스 다음 제거 요소를 찾을 수 있습니다 :

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

8. ==============================

   8.방법에 대한

   방법에 대한

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

   당신이 반환을 보면, 뭔가 잘못이있다.

9. ==============================

   9.폴드를 사용하여이 작업을 수행하는 방법에 그냥 다른 생각 :

   폴드를 사용하여이 작업을 수행하는 방법에 그냥 다른 생각 :

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

10. ==============================

    10.일반 꼬리 재귀 솔루션 :

    일반 꼬리 재귀 솔루션 :

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

11. ==============================

    11.

    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)
    

12. ==============================

    12.

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

from https://stackoverflow.com/questions/5636717/what-is-an-idiomatic-scala-way-to-remove-one-element-from-an-immutable-list by cc-by-sa and MIT license