We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
Loading...
  1. Practice
  2. Functional Programming
  3. Introduction
  4. Update List
  5. Discussions

Update List

  • Jack_Lee1_ + 5 comments

    For Scala

    import scala.math._
def f(arr:List[Int]):List[Int] = arr.map((a:Int) => abs(a))

    I feel it was a bit of cop out using the abs() function. Does anyone have a method to solve it using something tail recursive?

    • luizpericolo + 2 comments

      Here you go:

      def f(arr:List[Int]):List[Int] = {
    def absList(absed: List[Int], unabsed: List[Int]): List[Int] = {
        unabsed match {
            case Nil => absed
            case x :: xs => {
                x match {
                    case v if v < 0 => absList(absed :+ v * -1, xs)
                    case v => absList(absed :+ v, xs)
                }
            }
        }
    }
    absList(Nil, arr)
}

      Feel free to ask if you have any doubts.

      • bayalla_abdelka1 + 0 comments
        def fabs(arr:List[Int]):List[Int] = {

  def loop(arr:List[Int],acc:List[Int]):List[Int] = arr match {
    case Nil => Nil
    case h :: tail =>  h.abs :: loop(arr tail,acc)
  }
    
  loop(arr,List()) 
}
      • singhbijendra63 + 0 comments

        can you please explain case x :: xs what exactly this does

    • vestail + 0 comments

      or just

      arr.map(Math.abs)
    • MartinRosenberg + 0 comments

      Generally, I'd avoid cluttering the namespace with a wildcard import, especially given only one member of it is actually being used. Also, for members of scala, you can actually drop scala.:

      def f(arr: List[Int]): List[Int] = arr map math.abs
    • MartinRosenberg + 0 comments

      To avoid using math.abs:

      def f(arr: List[Int]): List[Int] = arr map (x => x * x.signum)

      And if you wanna do that with tail recursion:

      def f(arr: List[Int]): List[Int] = {
  @annotation.tailrec
  def run(i: Int, res: List[Int]): List[Int] = arr.length match {
    case `i` => res
    case _   => run(i + 1, res :+ arr(i) * arr(i).signum)
  }
  run(0, List.empty[Int])
}
    • sao_rahul + 0 comments

      "def f(arr:List[Int]):List[Int] = arr.map(x => if (x < 0 ) -x else x )"